SByte.TryParse Metodo

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Converte la rappresentazione di stringa di un numero nell'equivalente intero con segno a 8 bit. Un codice restituito indica se la conversione ha avuto esito positivo o negativo.

Overload

TryParse(ReadOnlySpan<Byte>, IFormatProvider, SByte)	Prova ad analizzare un intervallo di caratteri UTF-8 in un valore.
TryParse(ReadOnlySpan<Char>, SByte)	Tenta di convertire la rappresentazione di intervallo di un numero nell'equivalente SByte e restituisce un valore che indica se la conversione ha avuto esito positivo.
TryParse(String, SByte)	Tenta di convertire la rappresentazione di stringa di un numero nell'equivalente SByte e restituisce un valore che indica se la conversione è riuscita.
TryParse(ReadOnlySpan<Char>, IFormatProvider, SByte)	Tenta di analizzare un intervallo di caratteri in un valore.
TryParse(String, IFormatProvider, SByte)	Tenta di analizzare una stringa in un valore.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, SByte)	Prova ad analizzare un intervallo di caratteri UTF-8 in un valore.
TryParse(ReadOnlySpan<Byte>, SByte)	Prova a convertire un intervallo di caratteri UTF-8 contenente la rappresentazione di stringa di un numero nell'equivalente intero con segno a 8 bit.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, SByte)	Tenta di convertire la rappresentazione dell'intervallo di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel relativo equivalente SByte e restituisce un valore che indica se la conversione ha avuto esito positivo.
TryParse(String, NumberStyles, IFormatProvider, SByte)	Tenta di convertire la rappresentazione di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel relativo equivalente SByte e restituisce un valore che indica se la conversione ha avuto esito positivo.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, SByte)

Origine:

SByte.cs

Prova ad analizzare un intervallo di caratteri UTF-8 in un valore.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::SByte % result) = IUtf8SpanParsable<System::SByte>::TryParse;

public static bool TryParse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, out sbyte result);

static member TryParse : ReadOnlySpan<byte> * IFormatProvider * sbyte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider, ByRef result As SByte) As Boolean

Parametri

utf8Text

ReadOnlySpan<Byte>

Intervallo di caratteri UTF-8 da analizzare.

provider

IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su utf8Text.

result

SByte

In caso di restituzione, contiene il risultato dell'analisi corretta utf8Text o di un valore non definito in caso di errore.

Restituisce

Boolean

true se utf8Text è stato analizzato correttamente; in caso contrario, false.

TryParse(ReadOnlySpan<Char>, SByte)

Origine:

SByte.cs

Importante

Questa API non è conforme a CLS.

Tenta di convertire la rappresentazione di intervallo di un numero nell'equivalente SByte e restituisce un valore che indica se la conversione ha avuto esito positivo.

public:
 static bool TryParse(ReadOnlySpan<char> s, [Runtime::InteropServices::Out] System::SByte % result);

public static bool TryParse (ReadOnlySpan<char> s, out sbyte result);

static member TryParse : ReadOnlySpan<char> * sbyte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), ByRef result As SByte) As Boolean

Parametri

s

ReadOnlySpan<Char>

Intervallo contenente i caratteri che rappresentano il numero da convertire.

result

SByte

Quando termina, questo metodo contiene il valore intero con segno a 8 bit equivalente al numero contenuto in s se la conversione ha avuto esito positivo oppure zero se la conversione non è riuscita. La conversione non riesce se il parametro s è null o Empty, non è nel formato corretto oppure rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue. Questo parametro viene passato non inizializzato; qualsiasi valore originariamente fornito in result verrà sovrascritto.

Restituisce

Boolean

true se s è stata convertita correttamente; in caso contrario, false.

TryParse(String, SByte)

Origine:

SByte.cs

Importante

Questa API non è conforme a CLS.

Tenta di convertire la rappresentazione di stringa di un numero nell'equivalente SByte e restituisce un valore che indica se la conversione è riuscita.

public:
 static bool TryParse(System::String ^ s, [Runtime::InteropServices::Out] System::SByte % result);

public static bool TryParse (string? s, out sbyte result);

static member TryParse : string * sbyte -> bool

Public Shared Function TryParse (s As String, ByRef result As SByte) As Boolean

Parametri

s

String

Stringa contenente un numero da convertire.

result

SByte

Quando termina, questo metodo contiene il valore intero con segno a 8 bit equivalente al numero contenuto in s se la conversione ha avuto esito positivo oppure zero se la conversione non è riuscita. La conversione non riesce se il parametro s è null o Empty, non è nel formato corretto oppure rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue. Questo parametro viene passato non inizializzato; qualsiasi valore originariamente fornito in result verrà sovrascritto.

Restituisce

Boolean

true se s è stata convertita correttamente; in caso contrario, false.

Esempio

L'esempio seguente tenta di convertire le stringhe in una matrice in valori SByte chiamando il metodo TryParse(String, SByte).

string[] numericStrings = {"-3.6", "12.8", "+16.7", "    3   ", "(17)", 
                           "-17", "+12", "18-", "987", "1,024", "  127 "};
sbyte number;
foreach (string numericString in numericStrings)
{
   if (sbyte.TryParse(numericString, out number)) 
      Console.WriteLine("Converted '{0}' to {1}.", numericString, number);
   else
      Console.WriteLine("Cannot convert '{0}' to an SByte.", numericString);
}
// The example displays the following output to the console:
//       Cannot convert '-3.6' to an SByte.
//       Cannot convert '12.8' to an SByte.
//       Cannot convert '+16.7' to an SByte.
//       Converted '    3   ' to 3.
//       Cannot convert '(17)' to an SByte.
//       Converted '-17' to -17.
//       Converted '+12' to 12.
//       Cannot convert '18-' to an SByte.
//       Cannot convert '987' to an SByte.
//       Cannot convert '1,024' to an SByte.
//       Converted '  127 ' to 127.

open System

let numericStrings = 
    [| "-3.6"; "12.8"; "+16.7"; "    3   "; "(17)" 
       "-17"; "+12"; "18-"; "987"; "1,024"; "  127 " |]

for numericString in numericStrings do
    match SByte.TryParse numericString with 
    | true, number ->
        printfn $"Converted '{numericString}' to {number}."
    | _ ->
        printfn $"Cannot convert '{numericString}' to an SByte."
// The example displays the following output to the console:
//       Cannot convert '-3.6' to an SByte.
//       Cannot convert '12.8' to an SByte.
//       Cannot convert '+16.7' to an SByte.
//       Converted '    3   ' to 3.
//       Cannot convert '(17)' to an SByte.
//       Converted '-17' to -17.
//       Converted '+12' to 12.
//       Cannot convert '18-' to an SByte.
//       Cannot convert '987' to an SByte.
//       Cannot convert '1,024' to an SByte.
//       Converted '  127 ' to 127.

Dim numericStrings() As String = {"-3.6", "12.8", "+16.7", "    3   ", _
                                  "(17)", "-17", "+12", "18-", "987", _
                                  "1,024", "  127 "}
Dim number As SByte
For Each numericString As String In numericStrings
   If SByte.TryParse(numericString, number) Then
      Console.WriteLine("Converted '{0}' to {1}.", numericString, number)
   Else
      Console.WriteLine("Cannot convert '{0}' to an SByte.", numericString)
   End If      
Next
' The example displays the following output to the console:
'       Cannot convert '-3.6' to an SByte.
'       Cannot convert '12.8' to an SByte.
'       Cannot convert '+16.7' to an SByte.
'       Converted '    3   ' to 3.
'       Cannot convert '(17)' to an SByte.
'       Converted '-17' to -17.
'       Converted '+12' to 12.
'       Cannot convert '18-' to an SByte.
'       Cannot convert '987' to an SByte.
'       Cannot convert '1,024' to an SByte.
'       Converted '  127 ' to 127.

Commenti

Il metodo SByte.TryParse(String, SByte) è simile al metodo SByte.Parse(String), ad eccezione del fatto che non genera un'eccezione se la conversione non riesce. Questo metodo elimina la necessità di usare la gestione delle eccezioni per testare un FormatException se value non è valido e non può essere analizzato correttamente.

Il parametro s deve essere la rappresentazione di stringa di un numero decimale nel formato seguente:

[ws] [firma]cifre[ws]

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. La tabella seguente descrive ogni elemento.

Elemento	Descrizione
ws	Spazio vuoto facoltativo.
firmare	Segno facoltativo. I caratteri di segno validi sono determinati dalle proprietà NumberFormatInfo.NegativeSign e NumberFormatInfo.PositiveSign delle impostazioni cultura correnti.
cifre	Sequenza di cifre decimali comprese tra 0 e 9.

Nota

La stringa specificata dal parametro value non può contenere separatori di gruppo o separatori decimali e non può avere una parte decimale.

Il parametro s viene interpretato usando lo stile NumberStyles.Integer. Oltre alle cifre decimali, sono consentiti solo gli spazi iniziali e finali con un segno iniziale. Per definire in modo esplicito gli elementi di stile con le informazioni di formattazione specifiche delle impostazioni cultura che possono essere presenti in value, chiamare il metodo TryParse(String, NumberStyles, IFormatProvider, SByte).

Il parametro s viene analizzato usando le informazioni di formattazione in un oggetto NumberFormatInfo per le impostazioni cultura correnti. Per altre informazioni, vedere NumberFormatInfo.CurrentInfo.

Questo overload interpreta tutte le cifre nel parametro value come cifre decimali. Per analizzare la rappresentazione di stringa di un numero esadecimale, chiamare invece l'overload TryParse(String, NumberStyles, IFormatProvider, SByte).

Vedi anche

• esempio : Utilità di formattazione WinForms .NET Core (C#)
• esempio : Utilità di formattazione WinForms .NET Core (Visual Basic)

TryParse(ReadOnlySpan<Char>, IFormatProvider, SByte)

Origine:

SByte.cs

Tenta di analizzare un intervallo di caratteri in un valore.

public:
 static bool TryParse(ReadOnlySpan<char> s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::SByte % result) = ISpanParsable<System::SByte>::TryParse;

public static bool TryParse (ReadOnlySpan<char> s, IFormatProvider? provider, out sbyte result);

static member TryParse : ReadOnlySpan<char> * IFormatProvider * sbyte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), provider As IFormatProvider, ByRef result As SByte) As Boolean

Parametri

s

ReadOnlySpan<Char>

Intervallo di caratteri da analizzare.

provider

IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su s.

result

SByte

Quando termina, questo metodo contiene il risultato dell'analisi corretta so di un valore non definito in caso di errore.

Restituisce

Boolean

true se s è stato analizzato correttamente; in caso contrario, false.

TryParse(String, IFormatProvider, SByte)

Origine:

SByte.cs

Tenta di analizzare una stringa in un valore.

public:
 static bool TryParse(System::String ^ s, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::SByte % result) = IParsable<System::SByte>::TryParse;

public static bool TryParse (string? s, IFormatProvider? provider, out sbyte result);

static member TryParse : string * IFormatProvider * sbyte -> bool

Public Shared Function TryParse (s As String, provider As IFormatProvider, ByRef result As SByte) As Boolean

Parametri

s

String

Stringa da analizzare.

provider

IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su s.

result

SByte

Quando termina, questo metodo contiene il risultato dell'analisi corretta s o di un valore non definito in caso di errore.

Restituisce

Boolean

true se s è stato analizzato correttamente; in caso contrario, false.

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, SByte)

Origine:

SByte.cs

Prova ad analizzare un intervallo di caratteri UTF-8 in un valore.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::SByte % result) = System::Numerics::INumberBase<System::SByte>::TryParse;

public static bool TryParse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style, IFormatProvider? provider, out sbyte result);

static member TryParse : ReadOnlySpan<byte> * System.Globalization.NumberStyles * IFormatProvider * sbyte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), style As NumberStyles, provider As IFormatProvider, ByRef result As SByte) As Boolean

Parametri

utf8Text

ReadOnlySpan<Byte>

Intervallo di caratteri UTF-8 da analizzare.

style

NumberStyles

Combinazione bit per bit di stili numerici che possono essere presenti in utf8Text.

provider

IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su utf8Text.

result

SByte

In caso di restituzione, contiene il risultato dell'analisi corretta utf8Text o di un valore non definito in caso di errore.

Restituisce

Boolean

true se utf8Text è stato analizzato correttamente; in caso contrario, false.

TryParse(ReadOnlySpan<Byte>, SByte)

Origine:

SByte.cs

Prova a convertire un intervallo di caratteri UTF-8 contenente la rappresentazione di stringa di un numero nell'equivalente intero con segno a 8 bit.

public:
 static bool TryParse(ReadOnlySpan<System::Byte> utf8Text, [Runtime::InteropServices::Out] System::SByte % result);

public static bool TryParse (ReadOnlySpan<byte> utf8Text, out sbyte result);

static member TryParse : ReadOnlySpan<byte> * sbyte -> bool

Public Shared Function TryParse (utf8Text As ReadOnlySpan(Of Byte), ByRef result As SByte) As Boolean

Parametri

utf8Text

ReadOnlySpan<Byte>

Intervallo contenente i caratteri UTF-8 che rappresentano il numero da convertire.

result

SByte

Quando termina, questo metodo contiene il valore intero con segno a 8 bit equivalente al numero contenuto in utf8Text se la conversione ha avuto esito positivo oppure zero se la conversione non è riuscita. Questo parametro viene passato non inizializzato; qualsiasi valore specificato originariamente nel risultato verrà sovrascritto.

Restituisce

Boolean

true se utf8Text è stata convertita correttamente; in caso contrario, false.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, SByte)

Origine:

SByte.cs

Importante

Questa API non è conforme a CLS.

Tenta di convertire la rappresentazione dell'intervallo di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel relativo equivalente SByte e restituisce un valore che indica se la conversione ha avuto esito positivo.

public:
 static bool TryParse(ReadOnlySpan<char> s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::SByte % result) = System::Numerics::INumberBase<System::SByte>::TryParse;

public static bool TryParse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style, IFormatProvider? provider, out sbyte result);

static member TryParse : ReadOnlySpan<char> * System.Globalization.NumberStyles * IFormatProvider * sbyte -> bool

Public Shared Function TryParse (s As ReadOnlySpan(Of Char), style As NumberStyles, provider As IFormatProvider, ByRef result As SByte) As Boolean

Parametri

s

ReadOnlySpan<Char>

Intervallo contenente i caratteri che rappresentano il numero da convertire.

style

NumberStyles

Combinazione bit per bit di valori di enumerazione che indica il formato consentito di s. Un valore tipico da specificare è Integer.

provider

IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su s.

result

SByte

Quando termina, questo metodo contiene il valore intero con segno a 8 bit equivalente al numero contenuto in s, se la conversione ha avuto esito positivo o zero se la conversione non è riuscita. La conversione ha esito negativo se il parametro s è null o Empty, non è conforme a styleo rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue. Questo parametro viene passato non inizializzato; qualsiasi valore originariamente fornito in result verrà sovrascritto.

Restituisce

Boolean

true se s è stata convertita correttamente; in caso contrario, false.

TryParse(String, NumberStyles, IFormatProvider, SByte)

Origine:

SByte.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

System.Int16.TryParse(String, Int16)

Tenta di convertire la rappresentazione di stringa di un numero in uno stile specificato e in un formato specifico delle impostazioni cultura nel relativo equivalente SByte e restituisce un valore che indica se la conversione ha avuto esito positivo.

public:
 static bool TryParse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider, [Runtime::InteropServices::Out] System::SByte % result) = System::Numerics::INumberBase<System::SByte>::TryParse;

public static bool TryParse (string? s, System.Globalization.NumberStyles style, IFormatProvider? provider, out sbyte result);

static member TryParse : string * System.Globalization.NumberStyles * IFormatProvider * sbyte -> bool

Public Shared Function TryParse (s As String, style As NumberStyles, provider As IFormatProvider, ByRef result As SByte) As Boolean

Parametri

s

String

Stringa che rappresenta un numero da convertire.

style

NumberStyles

Combinazione bit per bit di valori di enumerazione che indica il formato consentito di s. Un valore tipico da specificare è Integer.

provider

IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su s.

result

SByte

Quando termina, questo metodo contiene il valore intero con segno a 8 bit equivalente al numero contenuto in s, se la conversione ha avuto esito positivo o zero se la conversione non è riuscita. La conversione ha esito negativo se il parametro s è null o Empty, non è conforme a styleo rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue. Questo parametro viene passato non inizializzato; qualsiasi valore originariamente fornito in result verrà sovrascritto.

Restituisce

Boolean

true se s è stata convertita correttamente; in caso contrario, false.

Eccezioni

ArgumentException

style non è un valore di NumberStyles.

-o-

style non è una combinazione di valori di AllowHexSpecifier e HexNumber.

Esempio

Nell'esempio seguente viene chiamato il metodo TryParse(String, NumberStyles, IFormatProvider, SByte) con diversi valori stringa e NumberStyles.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string numericString;
      NumberStyles styles;
      
      numericString = "106";
      styles = NumberStyles.Integer;
      CallTryParse(numericString, styles);
      
      numericString = "-106";
      styles = NumberStyles.None;
      CallTryParse(numericString, styles);
      
      numericString = "103.00";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(numericString, styles);
      
      numericString = "103.72";
      styles = NumberStyles.Integer | NumberStyles.AllowDecimalPoint;
      CallTryParse(numericString, styles);

      numericString = "10E-01";
      styles = NumberStyles.Integer | NumberStyles.AllowExponent;
      CallTryParse(numericString, styles); 
      
      numericString = "12E-01";
      CallTryParse(numericString, styles);
          
      numericString = "12E01";
      CallTryParse(numericString, styles); 
      
      numericString = "C8";
      CallTryParse(numericString, NumberStyles.HexNumber);
      
      numericString = "0x8C";
      CallTryParse(numericString, NumberStyles.HexNumber);
   }
   
   private static void CallTryParse(string stringToConvert, NumberStyles styles)
   {
      sbyte number;
      bool result = SByte.TryParse(stringToConvert, styles, 
                                   CultureInfo.InvariantCulture, out number);
      if (result)
         Console.WriteLine($"Converted '{stringToConvert}' to {number}.");
      else
         Console.WriteLine($"Attempted conversion of '{stringToConvert}' failed.");
   }
}
// The example displays the following output:
//       Converted '106' to 106.
//       Attempted conversion of '-106' failed.
//       Converted '103.00' to 103.
//       Attempted conversion of '103.72' failed.
//       Converted '10E-01' to 1.
//       Attempted conversion of '12E-01' failed.
//       Converted '12E01' to 120.
//       Converted 'C8' to -56.
//       Attempted conversion of '0x8C' failed.

open System
open System.Globalization

let callTryParse (stringToConvert: string) styles =
    match SByte.TryParse(stringToConvert, styles, CultureInfo.InvariantCulture) with
    | true, number ->
        printfn $"Converted '{stringToConvert}' to {number}."
    | _ ->
        printfn $"Attempted conversion of '{stringToConvert}' failed."

[<EntryPoint>]
let main _ =
    let numericString = "106"
    let styles = NumberStyles.Integer
    callTryParse numericString styles
    
    let numericString = "-106"
    let styles = NumberStyles.None
    callTryParse numericString styles
    
    let numericString = "103.00"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse numericString styles
    
    let numericString = "103.72"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowDecimalPoint
    callTryParse numericString styles

    let numericString = "10E-01"
    let styles = NumberStyles.Integer ||| NumberStyles.AllowExponent
    callTryParse numericString styles 
    
    let numericString = "12E-01"
    callTryParse numericString styles
        
    let numericString = "12E01"
    callTryParse numericString styles 
    
    let numericString = "C8"
    callTryParse numericString NumberStyles.HexNumber
    
    let numericString = "0x8C"
    callTryParse numericString NumberStyles.HexNumber
    0

// The example displays the following output:
//       Converted '106' to 106.
//       Attempted conversion of '-106' failed.
//       Converted '103.00' to 103.
//       Attempted conversion of '103.72' failed.
//       Converted '10E-01' to 1.
//       Attempted conversion of '12E-01' failed.
//       Converted '12E01' to 120.
//       Converted 'C8' to -56.
//       Attempted conversion of '0x8C' failed.

Imports System.Globalization

Module StringParsing
   Public Sub Main()
      Dim numericString As String
      Dim styles As NumberStyles
      
      numericString = "106"
      styles = NumberStyles.Integer
      CallTryParse(numericString, styles)
      
      numericString = "-106"
      styles = NumberStyles.None
      CallTryParse(numericString, styles)
      
      numericString = "103.00"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(numericString, styles)
      
      numericString = "103.72"
      styles = NumberStyles.Integer Or NumberStyles.AllowDecimalPoint
      CallTryParse(numericString, styles)

      numericString = "10E-01"
      styles = NumberStyles.Integer Or NumberStyles.AllowExponent
      CallTryParse(numericString, styles) 
      
      numericString = "12E-01"
      CallTryParse(numericString, styles)
          
      numericString = "12E01"
      CallTryParse(numericString, styles) 
      
      numericString = "C8"
      CallTryParse(numericString, NumberStyles.HexNumber)
      
      numericString = "0x8C"
      CallTryParse(numericString, NumberStyles.HexNumber)
   End Sub
   
   Private Sub CallTryParse(stringToConvert As String, styles AS NumberStyles)
      Dim number As SByte
      Dim result As Boolean = SByte.TryParse(stringToConvert, styles, _
                                             CultureInfo.InvariantCulture, number)
      If result Then
         Console.WriteLine("Converted '{0}' to {1}.", stringToConvert, number)
      Else
         Console.WriteLine("Attempted conversion of '{0}' failed.", _
                           Convert.ToString(stringToConvert))
      End If                                                                           
   End Sub
End Module
' The example displays the following output to the console:
'       Converted '106' to 106.
'       Attempted conversion of '-106' failed.
'       Converted '103.00' to 103.
'       Attempted conversion of '103.72' failed.
'       Converted '10E-01' to 1.
'       Attempted conversion of '12E-01' failed.
'       Converted '12E01' to 120.
'       Converted 'C8' to -56.
'       Attempted conversion of '0x8C' failed.

Commenti

Il metodo TryParse(String, NumberStyles, IFormatProvider, SByte) è simile al metodo Parse(String, NumberStyles, IFormatProvider), ad eccezione del fatto che non genera un'eccezione se la conversione non riesce. Questo metodo elimina la necessità di usare la gestione delle eccezioni per testare un FormatException se value non è valido e non può essere analizzato correttamente.

Il parametro style definisce gli elementi di stile(ad esempio uno spazio vuoto o un segno positivo o negativo) consentiti nel parametro value per l'esito positivo dell'operazione di analisi. Deve essere una combinazione di flag di bit dell'enumerazione NumberStyles. A seconda del valore di style, il parametro value può includere gli elementi seguenti:

[ws] [] [firma] [cifre,]cifre[.fractional_digits][E[ segno]exponential_digits][ws]

Se il parametro style include AllowHexSpecifier, il parametro value può includere gli elementi seguenti:

[ws]hexdigits[ws]

Gli elementi tra parentesi quadre ([ e ]) sono facoltativi. La tabella seguente descrive ogni elemento.

Elemento	Descrizione
ws	Spazio vuoto facoltativo. Gli spazi vuoti possono essere visualizzati all'inizio di value se style include il flag di NumberStyles.AllowLeadingWhite o alla fine di value se style include il flag NumberStyles.AllowTrailingWhite.
$	Simbolo di valuta specifico delle impostazioni cultura. La posizione nella stringa è definita dalla proprietà CurrencyPositivePattern dell'oggetto NumberFormatInfo restituito dal metodo GetFormat del parametro provider. Il simbolo di valuta può essere visualizzato in value se style include il flag di NumberStyles.AllowCurrencySymbol.
firmare	Segno facoltativo. Il segno può essere visualizzato all'inizio di value se style include il flag di NumberStyles.AllowLeadingSign e può essere visualizzato alla fine di value se style include il flag NumberStyles.AllowTrailingSign. Le parentesi possono essere usate in value per indicare un valore negativo se style include il flag NumberStyles.AllowParentheses.
cifre	Sequenza di cifre da 0 a 9.
,	Separatore di gruppo specifico delle impostazioni cultura. Il separatore di gruppo delle impostazioni cultura specificate da provider può essere visualizzato in value se style include il flag NumberStyles.AllowThousands.
.	Simbolo di virgola decimale specifica delle impostazioni cultura. Il simbolo di virgola decimale delle impostazioni cultura specificate da provider può essere visualizzato in value se style include il flag NumberStyles.AllowDecimalPoint.
fractional_digits	Una o più occorrenze della cifra 0. Le cifre frazionarie possono essere visualizzate in value solo se style include il flag di NumberStyles.AllowDecimalPoint.
E	Carattere "e" o "E", che indica che il valore è rappresentato nella notazione esponenziale (scientifica). Il parametro value può rappresentare un numero in notazione esponenziale se style include il flag NumberStyles.AllowExponent.
exponential_digits	Sequenza di cifre da 0 a 9. Il parametro value può rappresentare un numero in notazione esponenziale se style include il flag NumberStyles.AllowExponent.
hexdigits	Sequenza di cifre esadecimali da 0 a f o da 0 a F.

Nota

Qualsiasi carattere di terminazione NUL (U+0000) in s viene ignorato dall'operazione di analisi, indipendentemente dal valore dell'argomento style.

Una stringa con solo cifre decimali (che corrisponde al flag di NumberStyles.None) viene sempre analizzata correttamente. La maggior parte dei membri rimanenti NumberStyles elementi di controllo che possono essere presenti, ma non devono essere presenti, in questa stringa di input. La tabella seguente indica in che modo i singoli membri NumberStyles influiscono sugli elementi che possono essere presenti in value.

Valori di NumberStyles non compositi	Elementi consentiti in valore oltre alle cifre
None	Solo cifre decimali.
AllowDecimalPoint	Il separatore decimale (.) e gli elementi fractional_digits. Tuttavia, fractional_digits deve essere costituito da una o più cifre 0 oppure il metodo restituisce false.
AllowExponent	Carattere "e" o "E", che indica la notazione esponenziale, insieme a exponential_digits. Se value rappresenta un numero in notazione esponenziale, non può avere un componente frazionaria diverso da zero.
AllowLeadingWhite	Elemento ws all'inizio di value.
AllowTrailingWhite	Elemento ws alla fine di .
AllowLeadingSign	Elemento segno prima di cifre.
AllowTrailingSign	Elemento segno dopo cifre.
AllowParentheses	Elemento segno sotto forma di parentesi che racchiudono il valore numerico.
AllowThousands	Elemento separatore di gruppo (,).
AllowCurrencySymbol	Elemento currency ($).
Currency	Tutti gli elementi. Tuttavia, value non può rappresentare un numero esadecimale o un numero in notazione esponenziale.
Float	L'elemento ws all'inizio o alla fine di , segno all'inizio di e il simbolo decimale (.). Il parametro value può anche usare la notazione esponenziale.
Number	Gli elementi ws, segno, separatore di gruppo (,) e separatore decimale (.).
Any	Tutti gli elementi. Tuttavia, value non può rappresentare un numero esadecimale.

Se viene usato il flag NumberStyles.AllowHexSpecifier, value deve essere un valore esadecimale. Le cifre esadecimali valide sono 0-9, a-f e A-F. Gli unici flag che possono essere presenti in style sono NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. L'enumerazione NumberStyles ha uno stile composito, HexNumber, che include entrambi i flag di spazio vuoto.

Nota

Se value è la rappresentazione di stringa di un numero esadecimale, non può essere preceduta da alcuna decorazione (ad esempio 0x o &h) che la differenzia come numero esadecimale. In questo modo la conversione non riesce.

Il parametro provider è un'implementazione IFormatProvider. Il metodo GetFormat restituisce un oggetto NumberFormatInfo che fornisce informazioni specifiche delle impostazioni cultura sul formato di value. Il parametro provider può essere uno dei seguenti:

• Oggetto CultureInfo che rappresenta le impostazioni cultura che forniscono informazioni di formattazione. Il metodo GetFormat restituisce l'oggetto NumberFormatInfo che fornisce informazioni sulla formattazione numerica per tali impostazioni cultura.

• Oggetto NumberFormatInfo che fornisce informazioni sulla formattazione numerica. L'implementazione di GetFormat restituisce solo se stessa.

• Oggetto personalizzato che implementa IFormatProvider. Il metodo GetFormat crea un'istanza e restituisce l'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

Se provider è null, viene utilizzato l'oggetto NumberFormatInfo per le impostazioni cultura correnti.

Vedi anche

• Parse(String, NumberStyles, IFormatProvider)
• l'analisi di stringhe numeriche in .NET