SByte.Parse 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.

Overload

Parse(String, NumberStyles, IFormatProvider)	Converte la rappresentazione di stringa di un numero in uno stile e in un formato specifico delle impostazioni cultura specificati nell'equivalente con segno a 8 bit.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Converte la rappresentazione dell'intervallo di un numero in uno stile e in un formato specifico delle impostazioni cultura specificati nell'equivalente con segno a 8 bit.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analizza un intervallo di caratteri UTF-8 in un valore.
Parse(String, IFormatProvider)	Converte la rappresentazione di stringa di un numero in un formato specifico delle impostazioni cultura specificato nell'equivalente intero con segno a 8 bit.
Parse(String)	Converte la rappresentazione di stringa di un numero nell'equivalente intero con segno a 8 bit.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analizza un intervallo di caratteri in un valore.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analizza un intervallo di caratteri UTF-8 in un valore.
Parse(String, NumberStyles)	Converte la rappresentazione di stringa di un numero in uno stile specificato nell'equivalente intero con segno a 8 bit.

Parse(String, NumberStyles, IFormatProvider)

Origine:

SByte.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

System.Int16.Parse(String, NumberStyles, IFormatProvider)

Converte la rappresentazione di stringa di un numero in uno stile e in un formato specifico delle impostazioni cultura specificati nell'equivalente con segno a 8 bit.

public:
 static System::SByte Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<System::SByte>::Parse;

public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);

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

Public Shared Function Parse (s As String, style As NumberStyles, provider As IFormatProvider) As SByte

Parametri

s

String

Stringa contenente il numero da convertire. La stringa viene interpretata usando lo stile specificato da style.

style

NumberStyles

Combinazione bit per bit dei valori di enumerazione che indica gli elementi di stile che possono essere presenti in s. Un valore tipico da specificare è Integer.

provider

IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su s. Se provider è null, vengono usate le impostazioni cultura correnti del thread.

Restituisce

SByte

Valore di byte con segno a 8 bit equivalente al numero specificato nel parametro s.

Implementazioni

Parse(String, NumberStyles, IFormatProvider)

Eccezioni

ArgumentException

style non è un valore di NumberStyles.

-o-

style non è una combinazione di AllowHexSpecifier e HexNumber.

ArgumentNullException

s è null.

FormatException

s non è in un formato conforme a style.

OverflowException

s rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue.

-o-

s include cifre frazionarie diversi da zero.

Esempio

Nell'esempio seguente viene illustrato l'uso del metodo Parse(String, NumberStyles, IFormatProvider) per convertire varie rappresentazioni di stringa di numeri in valori integer con segno.

using System;
using System.Globalization;

public class SByteConversion
{
   NumberFormatInfo provider = NumberFormatInfo.CurrentInfo;

   public static void Main()
   {
      string stringValue;
      NumberStyles style;

      stringValue = "   123   ";
      style = NumberStyles.None;     
      CallParseOperation(stringValue, style);
      
      stringValue = "000,000,123";
      style = NumberStyles.Integer | NumberStyles.AllowThousands;
      CallParseOperation(stringValue, style);
      
      stringValue = "-100";
      style = NumberStyles.AllowLeadingSign;
      CallParseOperation(stringValue, style);
      
      stringValue = "100-";
      style = NumberStyles.AllowLeadingSign;
      CallParseOperation(stringValue, style);
      
      stringValue = "100-";
      style = NumberStyles.AllowTrailingSign;
      CallParseOperation(stringValue, style);
      
      stringValue = "$100";
      style = NumberStyles.AllowCurrencySymbol;
      CallParseOperation(stringValue, style);
      
      style = NumberStyles.Integer;
      CallParseOperation(stringValue, style);
      
      style = NumberStyles.AllowDecimalPoint;
      CallParseOperation("100.0", style);
      
      stringValue = "1e02";
      style = NumberStyles.AllowExponent;
      CallParseOperation(stringValue, style);
      
      stringValue = "(100)";
      style = NumberStyles.AllowParentheses;
      CallParseOperation(stringValue, style);
   }
   
   private static void CallParseOperation(string stringValue, 
                                          NumberStyles style)
   {                                          
      sbyte number;
      
      if (stringValue == null)
         Console.WriteLine("Cannot parse a null string...");
         
      try
      {
         number = sbyte.Parse(stringValue, style);
         Console.WriteLine("SByte.Parse('{0}', {1})) = {2}", 
                           stringValue, style, number);   
      }
      catch (FormatException)
      {
         Console.WriteLine("'{0}' and {1} throw a FormatException", 
                           stringValue, style);   
      }      
      catch (OverflowException)
      {
         Console.WriteLine("'{0}' is outside the range of a signed byte",
                           stringValue);
      }
   }
}
// The example displays the following information to the console:
//       '   123   ' and None throw a FormatException
//       SByte.Parse('000,000,123', Integer, AllowThousands)) = 123
//       SByte.Parse('-100', AllowLeadingSign)) = -100
//       '100-' and AllowLeadingSign throw a FormatException
//       SByte.Parse('100-', AllowTrailingSign)) = -100
//       SByte.Parse('$100', AllowCurrencySymbol)) = 100
//       '$100' and Integer throw a FormatException
//       SByte.Parse('100.0', AllowDecimalPoint)) = 100
//       SByte.Parse('1e02', AllowExponent)) = 100
//       SByte.Parse('(100)', AllowParentheses)) = -100

open System
open System.Globalization

let provider = NumberFormatInfo.CurrentInfo
   
let callParseOperation stringValue (style: NumberStyles) =
    if stringValue = null then
        printfn "Cannot parse a null string..."
    else
        try
            let number = SByte.Parse(stringValue, style)
            printfn $"SByte.Parse('{stringValue}', {style})) = {number}" 
        with
        | :? FormatException ->
            printfn $"'{stringValue}' and {style} throw a FormatException"
        | :? OverflowException ->
            printfn $"'{stringValue}' is outside the range of a signed byte"

[<EntryPoint>]
let main _ =
    let stringValue = "   123   "
    let style = NumberStyles.None     
    callParseOperation stringValue style
    
    let stringValue = "000,000,123"
    let style = NumberStyles.Integer ||| NumberStyles.AllowThousands
    callParseOperation stringValue style
    
    let stringValue = "-100"
    let style = NumberStyles.AllowLeadingSign
    callParseOperation stringValue style
    
    let stringValue = "100-"
    let style = NumberStyles.AllowLeadingSign
    callParseOperation stringValue style
    
    let stringValue = "100-"
    let style = NumberStyles.AllowTrailingSign
    callParseOperation stringValue style
    
    let stringValue = "$100"
    let style = NumberStyles.AllowCurrencySymbol
    callParseOperation stringValue style
    
    let style = NumberStyles.Integer
    callParseOperation stringValue style
    
    let style = NumberStyles.AllowDecimalPoint
    callParseOperation "100.0" style
    
    let stringValue = "1e02"
    let style = NumberStyles.AllowExponent
    callParseOperation stringValue style
    
    let stringValue = "(100)"
    let style = NumberStyles.AllowParentheses
    callParseOperation stringValue style
    0

// The example displays the following information to the console:
//       '   123   ' and None throw a FormatException
//       SByte.Parse('000,000,123', Integer, AllowThousands)) = 123
//       SByte.Parse('-100', AllowLeadingSign)) = -100
//       '100-' and AllowLeadingSign throw a FormatException
//       SByte.Parse('100-', AllowTrailingSign)) = -100
//       SByte.Parse('$100', AllowCurrencySymbol)) = 100
//       '$100' and Integer throw a FormatException
//       SByte.Parse('100.0', AllowDecimalPoint)) = 100
//       SByte.Parse('1e02', AllowExponent)) = 100
//       SByte.Parse('(100)', AllowParentheses)) = -100

Imports System.Globalization

Module modMain
   Public Sub Main()
      Dim byteString As String 
      
      byteString = " 123"
      ParseString(byteString, NumberStyles.None)
      ParseString(byteString, NumberStyles.Integer)
      
      byteString = "3A"
      ParseString(byteString, NumberStyles.AllowHexSpecifier) 
      
      byteString = "21"
      ParseString(byteString, NumberStyles.Integer)
      ParseString(byteString, NumberStyles.AllowHexSpecifier)
      
      byteString = "-22"
      ParseString(byteString, NumberStyles.Integer)
      ParseString(byteString, NumberStyles.AllowParentheses)
      
      byteString = "(45)"
      ParseString(byteString, NumberStyles.AllowParentheses)
     
      byteString = "000,000,056"
      ParseString(byteString, NumberStyles.Integer)
      ParseString(byteString, NumberStyles.Integer Or NumberStyles.AllowThousands)
   End Sub
   
   Private Sub ParseString(value As String, style As NumberStyles)
      Dim number As SByte
      
      If value Is Nothing Then Console.WriteLine("Cannot parse a null string...") 
      
      Try
         number = SByte.Parse(value, style, NumberFormatInfo.CurrentInfo)
         Console.WriteLine("SByte.Parse('{0}', {1}) = {2}", value, style, number)   
      Catch e As FormatException
         Console.WriteLine("'{0}' and {1} throw a FormatException", value, style)   
      Catch e As OverflowException
         Console.WriteLine("'{0}' is outside the range of a signed byte",
                           value)
      End Try     
   End Sub
End Module
' The example displays the following information to the console:
'       ' 123' and None throw a FormatException
'       SByte.Parse(" 123", Integer)) = 123
'       SByte.Parse("3A", AllowHexSpecifier)) = 58
'       SByte.Parse("21", Integer)) = 21
'       SByte.Parse("21", AllowHexSpecifier)) = 33
'       SByte.Parse("-22", Integer)) = -22
'       '-22' and AllowParentheses throw a FormatException
'       SByte.Parse("(45)", AllowParentheses)) = -45
'       '000,000,056' and Integer throw a FormatException
'       SByte.Parse("000,000,056", Integer, AllowThousands)) = 56

Commenti

Il parametro style definisce gli elementi di stile,ad esempio lo spazio vuoto o il simbolo di segno positivo o negativo, consentiti nel parametro s 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 s può includere gli elementi seguenti:

[ws] [$] [sign]digits[.fractional_digits][E[sign]exponential_digits][ws]

Se style include AllowHexSpecifier, il parametro s 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 s se style include il flag di NumberStyles.AllowLeadingWhite e possono essere visualizzati alla fine di s se style include il flag NumberStyles.AllowTrailingWhite.
$	Simbolo di valuta specifico delle impostazioni cultura. La posizione nella stringa è definita dalla proprietà NumberFormatInfo.CurrencyPositivePattern delle impostazioni cultura correnti. Il simbolo di valuta delle impostazioni cultura corrente può essere visualizzato in s se style include il flag NumberStyles.AllowCurrencySymbol.
firmare	Segno facoltativo. Il segno può essere visualizzato all'inizio di s se style include il flag di NumberStyles.AllowLeadingSign e può apparire la fine di s se style include il flag NumberStyles.AllowTrailingSign. Le parentesi possono essere usate in s per indicare un valore negativo se style include il flag NumberStyles.AllowParentheses.
cifre	Sequenza di cifre da 0 a 9.
.	Simbolo di virgola decimale specifica delle impostazioni cultura. Il simbolo decimale delle impostazioni cultura corrente può essere visualizzato in s se style include il flag NumberStyles.AllowDecimalPoint.
fractional_digits	Una o più occorrenze della cifra 0-9 se style include il flag di NumberStyles.AllowExponent o una o più occorrenze della cifra 0 in caso contrario. Le cifre frazionarie possono essere visualizzate in s 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 s 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 s 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 allo stile 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 s.

Valori di NumberStyles non compositi	Elementi consentiti in s oltre alle cifre
NumberStyles.None	Solo cifre decimali.
NumberStyles.AllowDecimalPoint	Il separatore decimale (.) e gli elementi fractional_digits. Tuttavia, se lo stile non include il flag NumberStyles.AllowExponent, fractional_digits deve essere costituito da una o più cifre 0; in caso contrario, viene generata una OverflowException.
NumberStyles.AllowExponent	Carattere "e" o "E", che indica la notazione esponenziale, insieme a exponential_digits.
NumberStyles.AllowLeadingWhite	Elemento ws all'inizio di .
NumberStyles.AllowTrailingWhite	Elemento ws alla fine di .
NumberStyles.AllowLeadingSign	Segno positivo prima di cifre.
NumberStyles.AllowTrailingSign	Segno positivo dopo cifre.
NumberStyles.AllowParentheses	Parentesi prima e dopo cifre per indicare un valore negativo.
NumberStyles.AllowThousands	Elemento separatore di gruppo (,). Anche se il separatore di gruppo può essere visualizzato in s, deve essere preceduto da una o più cifre 0.
NumberStyles.AllowCurrencySymbol	Elemento currency ($).

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

Nota

Se il parametro s è la rappresentazione di stringa di un numero esadecimale, non può essere preceduto da alcuna decorazione (ad esempio 0x o &h) che la differenzia come numero esadecimale. In questo modo, l'operazione di analisi genera un'eccezione.

Se s rappresenta un numero esadecimale, il metodo Parse(String, NumberStyles) interpreta il bit di ordine elevato del byte come bit di segno.

Il parametro provider è un'implementazione IFormatProvider il cui metodo GetFormat restituisce un oggetto NumberFormatInfo che fornisce informazioni specifiche delle impostazioni cultura sul formato di s. Esistono tre modi per usare il parametro provider per fornire informazioni di formattazione personalizzate all'operazione di analisi:

• È possibile passare l'oggetto NumberFormatInfo effettivo che fornisce informazioni di formattazione. L'implementazione di GetFormat restituisce semplicemente se stessa.

• È possibile passare un oggetto CultureInfo che specifica le impostazioni cultura di cui utilizzare la formattazione. La proprietà NumberFormat fornisce informazioni di formattazione.

• È possibile passare un'implementazione di IFormatProvider personalizzata. Il metodo GetFormat deve creare un'istanza e restituire l'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

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

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Origine:

SByte.cs

Importante

Questa API non è conforme a CLS.

Converte la rappresentazione dell'intervallo di un numero in uno stile e in un formato specifico delle impostazioni cultura specificati nell'equivalente con segno a 8 bit.

public static sbyte Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

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

Public Shared Function Parse (s As ReadOnlySpan(Of Char), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As SByte

Parametri

s

ReadOnlySpan<Char>

Intervallo contenente i caratteri che rappresentano il numero da convertire. L'intervallo viene interpretato usando lo stile specificato da style.

style

NumberStyles

Combinazione bit per bit dei valori di enumerazione che indica gli elementi di stile che possono essere presenti in s. Un valore tipico da specificare è Integer.

provider

IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su s. Se provider è null, vengono usate le impostazioni cultura correnti del thread.

Restituisce

SByte

Valore di byte con segno a 8 bit equivalente al numero specificato nel parametro s.

Implementazioni

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Origine:

SByte.cs

Analizza un intervallo di caratteri UTF-8 in un valore.

public static sbyte Parse (ReadOnlySpan<byte> utf8Text, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);

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

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), Optional style As NumberStyles = System.Globalization.NumberStyles.Integer, Optional provider As IFormatProvider = Nothing) As SByte

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.

Restituisce

SByte

Risultato dell'analisi utf8Text.

Implementazioni

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Parse(String, IFormatProvider)

Origine:

SByte.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

System.Int16.Parse(String)

Converte la rappresentazione di stringa di un numero in un formato specifico delle impostazioni cultura specificato nell'equivalente intero con segno a 8 bit.

public:
 static System::SByte Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<System::SByte>::Parse;

public static sbyte Parse (string s, IFormatProvider? provider);

static member Parse : string * IFormatProvider -> sbyte

Public Shared Function Parse (s As String, provider As IFormatProvider) As SByte

Parametri

s

String

Stringa che rappresenta un numero da convertire. La stringa viene interpretata usando lo stile Integer.

provider

IFormatProvider

Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura su s. Se provider è null, vengono usate le impostazioni cultura correnti del thread.

Restituisce

SByte

Intero con segno a 8 bit equivalente al numero specificato in s.

Implementazioni

Parse(String, IFormatProvider)

Eccezioni

ArgumentNullException

s è null.

FormatException

s non è nel formato corretto.

OverflowException

s rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue.

Esempio

Nell'esempio seguente viene definito un oggetto NumberFormatInfo personalizzato che definisce la tilde (~) come segno negativo. Analizza quindi una serie di stringhe numeriche usando questo oggetto personalizzato NumberFormatInfo nonché un oggetto CultureInfo che rappresenta le impostazioni cultura invarianti.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberFormatInfo nf = new NumberFormatInfo();
      nf.NegativeSign = "~"; 
      
      string[] values = { "-103", "+12", "~16", "  1", "~255" };
      IFormatProvider[] providers = { nf, CultureInfo.InvariantCulture };
      
      foreach (IFormatProvider provider in providers)
      {
         Console.WriteLine("Conversions using {0}:", ((object) provider).GetType().Name);
         foreach (string value in values)
         {
            try {
               Console.WriteLine("   Converted '{0}' to {1}.", 
                                 value, SByte.Parse(value, provider));
            }                     
            catch (FormatException) {
               Console.WriteLine("   Unable to parse '{0}'.", value);   
            }
            catch (OverflowException) {
               Console.WriteLine("   '{0}' is out of range of the SByte type.", value);         
            }
         }
      }      
   }
}
// The example displays the following output:
//       Conversions using NumberFormatInfo:
//          Unable to parse '-103'.
//          Converted '+12' to 12.
//          Converted '~16' to -16.
//          Converted '  1' to 1.
//          '~255' is out of range of the SByte type.
//       Conversions using CultureInfo:
//          Converted '-103' to -103.
//          Converted '+12' to 12.
//          Unable to parse '~16'.
//          Converted '  1' to 1.
//          Unable to parse '~255'.

open System
open System.Globalization

let nf = NumberFormatInfo()
nf.NegativeSign <- "~" 

let values = [| "-103"; "+12"; "~16"; "  1"; "~255" |]
let providers: IFormatProvider[] = [| nf; CultureInfo.InvariantCulture |]

for provider in providers do
    printfn $"Conversions using {(box provider).GetType().Name}:"
    for value in values do
        try
            printfn $"   Converted '{value}' to {SByte.Parse(value, provider)}."
        with
        | :? FormatException ->
            printfn $"   Unable to parse '{value}'."
        | :? OverflowException ->
            printfn $"   '{value}' is out of range of the SByte type."

// The example displays the following output:
//       Conversions using NumberFormatInfo:
//          Unable to parse '-103'.
//          Converted '+12' to 12.
//          Converted '~16' to -16.
//          Converted '  1' to 1.
//          '~255' is out of range of the SByte type.
//       Conversions using CultureInfo:
//          Converted '-103' to -103.
//          Converted '+12' to 12.
//          Unable to parse '~16'.
//          Converted '  1' to 1.
//          Unable to parse '~255'.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim nf As New NumberFormatInfo()
      nf.NegativeSign = "~" 
      
      Dim values() As String = { "-103", "+12", "~16", "  1", "~255" }
      Dim providers() As IFormatProvider = { nf, CultureInfo.InvariantCulture }
      
      For Each provider As IFormatProvider In providers
         Console.WriteLine("Conversions using {0}:", CObj(provider).GetType().Name)
         For Each value As String In values
            Try
               Console.WriteLine("   Converted '{0}' to {1}.", _
                                 value, SByte.Parse(value, provider))
            Catch e As FormatException
               Console.WriteLine("   Unable to parse '{0}'.", value)   
            Catch e As OverflowException
               Console.WriteLine("   '{0}' is out of range of the SByte type.", value)         
            End Try
         Next
      Next      
   End Sub
End Module
' The example displays '
'       Conversions using NumberFormatInfo:
'          Unable to parse '-103'.
'          Converted '+12' to 12.
'          Converted '~16' to -16.
'          Converted '  1' to 1.
'          '~255' is out of range of the SByte type.
'       Conversions using CultureInfo:
'          Converted '-103' to -103.
'          Converted '+12' to 12.
'          Unable to parse '~16'.
'          Converted '  1' to 1.
'          Unable to parse '~255'.

Commenti

Il parametro s contiene un numero di form:

[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.
cifre	Sequenza di cifre compresa tra 0 e 9.

Il parametro s viene interpretato usando lo stile Integer. Oltre alle cifre decimali del valore di byte, 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 s, usare il metodo Parse(String, NumberStyles, IFormatProvider).

Il parametro provider è un'implementazione IFormatProvider il cui metodo GetFormat restituisce un oggetto NumberFormatInfo che fornisce informazioni specifiche delle impostazioni cultura sul formato di s. Esistono tre modi per usare il parametro provider per fornire informazioni di formattazione personalizzate all'operazione di analisi:

• È possibile passare l'oggetto NumberFormatInfo effettivo che fornisce informazioni di formattazione. L'implementazione di GetFormat restituisce semplicemente se stessa.

• È possibile passare un oggetto CultureInfo che specifica le impostazioni cultura di cui utilizzare la formattazione. La proprietà NumberFormat fornisce informazioni di formattazione.

• È possibile passare un'implementazione di IFormatProvider personalizzata. Il metodo GetFormat deve creare un'istanza e restituire l'oggetto NumberFormatInfo che fornisce informazioni di formattazione.

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

Vedi anche

• ToString()
• TryParse
• l'analisi di stringhe numeriche in .NET

Parse(String)

Origine:

SByte.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

System.Int16.Parse(String)

Converte la rappresentazione di stringa di un numero nell'equivalente intero con segno a 8 bit.

public:
 static System::SByte Parse(System::String ^ s);

public static sbyte Parse (string s);

static member Parse : string -> sbyte

Public Shared Function Parse (s As String) As SByte

Parametri

s

String

Stringa che rappresenta un numero da convertire. La stringa viene interpretata usando lo stile Integer.

Restituisce

SByte

Intero con segno a 8 bit equivalente al numero contenuto nel parametro s.

Eccezioni

ArgumentException

s è null.

FormatException

s non è costituito da un segno facoltativo seguito da una sequenza di cifre (da zero a nove).

OverflowException

s rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue.

Esempio

Nell'esempio seguente viene illustrato come convertire un valore stringa in un valore di byte firmato usando il metodo Parse. Il valore di byte firmato risultante viene quindi visualizzato nella console.

// Define an array of numeric strings.
string[] values = { "-16", "  -3", "+ 12", " +12 ", "  12  ",
                    "+120", "(103)", "192", "-160" };
                           
// Parse each string and display the result.
foreach (string value in values)
{
   try {
      Console.WriteLine("Converted '{0}' to the SByte value {1}.",
                        value, SByte.Parse(value));
   }
   catch (FormatException) {
      Console.WriteLine("'{0}' cannot be parsed successfully by SByte type.",
                        value);
   }                              
   catch (OverflowException) {
      Console.WriteLine("'{0}' is out of range of the SByte type.",
                        value);
   }                                                                        
}
// The example displays the following output:
//       Converted '-16' to the SByte value -16.
//       Converted '  -3' to the SByte value -3.
//       '+ 12' cannot be parsed successfully by SByte type.
//       Converted ' +12 ' to the SByte value 12.
//       Converted '  12  ' to the SByte value 12.
//       Converted '+120' to the SByte value 120.
//       '(103)' cannot be parsed successfully by SByte type.
//       '192' is out of range of the SByte type.
//       '-160' is out of range of the SByte type.

open System

// Define an array of numeric strings.
let values = 
    [| "-16"; "  -3"; "+ 12"; " +12 "; "  12  "
       "+120"; "(103)"; "192"; "-160" |]
                            
// Parse each string and display the result.
for value in values do
    try
        printfn $"Converted '{value}' to the SByte value {SByte.Parse value}."
    with
    | :? FormatException ->
        printfn $"'{value}' cannot be parsed successfully by SByte type."
    | :? OverflowException ->
        printfn $"'{value}' is out of range of the SByte type."
        
// The example displays the following output:
//       Converted '-16' to the SByte value -16.
//       Converted '  -3' to the SByte value -3.
//       '+ 12' cannot be parsed successfully by SByte type.
//       Converted ' +12 ' to the SByte value 12.
//       Converted '  12  ' to the SByte value 12.
//       Converted '+120' to the SByte value 120.
//       '(103)' cannot be parsed successfully by SByte type.
//       '192' is out of range of the SByte type.
//       '-160' is out of range of the SByte type.

' Define an array of numeric strings.
Dim values() As String = { "-16", "  -3", "+ 12", " +12 ", "  12  ", _
                           "+120", "(103)", "192", "-160" }
                           
' Parse each string and display the result.
For Each value As String In values
   Try
      Console.WriteLine("Converted '{0}' to the SByte value {1}.", _
                        value, SByte.Parse(value))
   Catch e As FormatException
      Console.WriteLine("'{0}' cannot be parsed successfully by SByte type.", _
                        value)
   Catch e As OverflowException
      Console.WriteLine("'{0}' is out of range of the SByte type.", _
                        value)
   End Try                                                                        
Next        
' The example displays the following output:
'       Converted '-16' to the SByte value -16.
'       Converted '  -3' to the SByte value -3.
'       '+ 12' cannot be parsed successfully by SByte type.
'       Converted ' +12 ' to the SByte value 12.
'       Converted '  12  ' to the SByte value 12.
'       Converted '+120' to the SByte value 120.
'       '(103)' cannot be parsed successfully by SByte type.
'       '192' is out of range of the SByte type.
'       '-160' is out of range of the SByte type.

Commenti

Il parametro s contiene un numero di form:

[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.
cifre	Sequenza di cifre compresa tra 0 e 9.

Il parametro s viene interpretato usando lo stile NumberStyles.Integer. Oltre alle cifre decimali del valore di byte, sono consentiti solo spazi iniziali e finali con un segno positivo o negativo iniziale. Per definire in modo esplicito gli elementi di stile che possono essere presenti in s, utilizzare il Parse(String, NumberStyles) o il metodo Parse(String, NumberStyles, IFormatProvider).

Il parametro s viene analizzato usando le informazioni di formattazione in un NumberFormatInfo inizializzato per le impostazioni cultura di sistema correnti. Per altre informazioni, vedere NumberFormatInfo.CurrentInfo. Per analizzare una stringa usando le informazioni di formattazione di altre impostazioni cultura, usare il metodo Parse(String, NumberStyles, IFormatProvider).

Vedi anche

• l'analisi di stringhe numeriche in .NET
• Tipi di formattazione in .NET

Parse(ReadOnlySpan<Char>, IFormatProvider)

Origine:

SByte.cs

Analizza un intervallo di caratteri in un valore.

public:
 static System::SByte Parse(ReadOnlySpan<char> s, IFormatProvider ^ provider) = ISpanParsable<System::SByte>::Parse;

public static sbyte Parse (ReadOnlySpan<char> s, IFormatProvider? provider);

static member Parse : ReadOnlySpan<char> * IFormatProvider -> sbyte

Public Shared Function Parse (s As ReadOnlySpan(Of Char), provider As IFormatProvider) As SByte

Parametri

s

ReadOnlySpan<Char>

Intervallo di caratteri da analizzare.

provider

IFormatProvider

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

Restituisce

SByte

Risultato dell'analisi s.

Implementazioni

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Origine:

SByte.cs

Analizza un intervallo di caratteri UTF-8 in un valore.

public:
 static System::SByte Parse(ReadOnlySpan<System::Byte> utf8Text, IFormatProvider ^ provider) = IUtf8SpanParsable<System::SByte>::Parse;

public static sbyte Parse (ReadOnlySpan<byte> utf8Text, IFormatProvider? provider);

static member Parse : ReadOnlySpan<byte> * IFormatProvider -> sbyte

Public Shared Function Parse (utf8Text As ReadOnlySpan(Of Byte), provider As IFormatProvider) As SByte

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.

Restituisce

SByte

Risultato dell'analisi utf8Text.

Implementazioni

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Parse(String, NumberStyles)

Origine:

SByte.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

System.Int16.Parse(String)

Converte la rappresentazione di stringa di un numero in uno stile specificato nell'equivalente intero con segno a 8 bit.

public:
 static System::SByte Parse(System::String ^ s, System::Globalization::NumberStyles style);

public static sbyte Parse (string s, System.Globalization.NumberStyles style);

static member Parse : string * System.Globalization.NumberStyles -> sbyte

Public Shared Function Parse (s As String, style As NumberStyles) As SByte

Parametri

s

String

Stringa contenente un numero da convertire. La stringa viene interpretata usando lo stile specificato da style.

style

NumberStyles

Combinazione bit per bit dei valori di enumerazione che indica gli elementi di stile che possono essere presenti in s. Un valore tipico da specificare è Integer.

Restituisce

SByte

Intero con segno a 8 bit equivalente al numero specificato in s.

Eccezioni

ArgumentNullException

s è null.

FormatException

s non è in un formato conforme a style.

OverflowException

s rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue.

-o-

s include cifre frazionarie diversi da zero.

ArgumentException

style non è un valore di NumberStyles.

-o-

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

Esempio

Nell'esempio seguente vengono analizzate le rappresentazioni di stringa dei valori di SByte con il metodo Parse(String, NumberStyles). Le impostazioni cultura correnti per l'esempio sono en-US.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      NumberStyles style;
      sbyte number;

      // Parse value with no styles allowed.
      string[] values1 = { " 121 ", "121", "-121" };
      style = NumberStyles.None;
      Console.WriteLine("Styles: {0}", style.ToString());
      foreach (string value in values1)
      {
         try {
            number = SByte.Parse(value, style);
            Console.WriteLine("   Converted '{0}' to {1}.", value, number);
         }   
         catch (FormatException) {
            Console.WriteLine("   Unable to parse '{0}'.", value);
         }
      }
      Console.WriteLine();
            
      // Parse value with trailing sign.
      style = NumberStyles.Integer | NumberStyles.AllowTrailingSign;
      string[] values2 = { " 103+", " 103 +", "+103", "(103)", "   +103  " };
      Console.WriteLine("Styles: {0}", style.ToString());
      foreach (string value in values2)
      {
         try {
            number = SByte.Parse(value, style);
            Console.WriteLine("   Converted '{0}' to {1}.", value, number);
         }   
         catch (FormatException) {
            Console.WriteLine("   Unable to parse '{0}'.", value);
         }      
         catch (OverflowException) {
            Console.WriteLine("   '{0}' is out of range of the SByte type.", value);         
         }
      }      
      Console.WriteLine();
   }
}
// The example displays the following output:
//       Styles: None
//          Unable to parse ' 121 '.
//          Converted '121' to 121.
//          Unable to parse '-121'.
//       
//       Styles: Integer, AllowTrailingSign
//          Converted ' 103+' to 103.
//          Converted ' 103 +' to 103.
//          Converted '+103' to 103.
//          Unable to parse '(103)'.
//          Converted '   +103  ' to 103.

open System
open System.Globalization

// Parse value with no styles allowed.
let values1 = [| " 121 "; "121"; "-121" |]
let style = NumberStyles.None
printfn $"Styles: {style}"
for value in values1 do
    try
        let number = SByte.Parse(value, style)
        printfn $"   Converted '{value}' to {number}."
    with :? FormatException ->
        printfn $"   Unable to parse '{value}'."
printfn ""
            
// Parse value with trailing sign.
let style2 = NumberStyles.Integer ||| NumberStyles.AllowTrailingSign
let values2 = [| " 103+"; " 103 +"; "+103"; "(103)"; "   +103  " |]
printfn $"Styles: {style2}"
for value in values2 do
    try
        let number = SByte.Parse(value, style2)
        printfn $"   Converted '{value}' to {number}."
    with 
    | :? FormatException ->
        printfn $"   Unable to parse '{value}'."
    | :? OverflowException ->
        printfn $"   '{value}' is out of range of the SByte type."         
printfn ""
// The example displays the following output:
//       Styles: None
//          Unable to parse ' 121 '.
//          Converted '121' to 121.
//          Unable to parse '-121'.
//       
//       Styles: Integer, AllowTrailingSign
//          Converted ' 103+' to 103.
//          Converted ' 103 +' to 103.
//          Converted '+103' to 103.
//          Unable to parse '(103)'.
//          Converted '   +103  ' to 103.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim style As NumberStyles
      Dim number As SByte

      ' Parse value with no styles allowed.
      Dim values1() As String = { " 121 ", "121", "-121" }
      style = NumberStyles.None
      Console.WriteLine("Styles: {0}", style.ToString())
      For Each value As String In values1
         Try
            number = SByte.Parse(value, style)
            Console.WriteLine("   Converted '{0}' to {1}.", value, number)
         Catch e As FormatException
            Console.WriteLine("   Unable to parse '{0}'.", value)   
         End Try
      Next
      Console.WriteLine()
            
      ' Parse value with trailing sign.
      style = NumberStyles.Integer Or NumberStyles.AllowTrailingSign
      Dim values2() As String = { " 103+", " 103 +", "+103", "(103)", "   +103  " }
      Console.WriteLine("Styles: {0}", style.ToString())
      For Each value As String In values2
         Try
            number = SByte.Parse(value, style)
            Console.WriteLine("   Converted '{0}' to {1}.", value, number)
         Catch e As FormatException
            Console.WriteLine("   Unable to parse '{0}'.", value)   
         Catch e As OverflowException
            Console.WriteLine("   '{0}' is out of range of the SByte type.", value)         
         End Try
      Next      
      Console.WriteLine()
   End Sub
End Module
' The example displays the following output:
'       Styles: None
'          Unable to parse ' 121 '.
'          Converted '121' to 121.
'          Unable to parse '-121'.
'       
'       Styles: Integer, AllowTrailingSign
'          Converted ' 103+' to 103.
'          Converted ' 103 +' to 103.
'          Converted '+103' to 103.
'          Unable to parse '(103)'.
'          Converted '   +103  ' to 103.

Commenti

Il parametro style definisce gli elementi di stile,ad esempio lo spazio vuoto o il simbolo di segno positivo o negativo, consentiti nel parametro s 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 s può includere gli elementi seguenti:

[ws] [$] [sign]digits[.fractional_digits][E[sign]exponential_digits][ws]

Se style include NumberStyles.AllowHexSpecifier, il parametro s può contenere 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 s se style include il flag di NumberStyles.AllowLeadingWhite e possono essere visualizzati alla fine di s se lo stile include il flag di NumberStyles.AllowTrailingWhite.
$	Simbolo di valuta specifico delle impostazioni cultura. La posizione nella stringa è definita dalla proprietà NumberFormatInfo.CurrencyPositivePattern delle impostazioni cultura correnti. Il simbolo di valuta delle impostazioni cultura corrente può essere visualizzato in s se style include il flag NumberStyles.AllowCurrencySymbol.
firmare	Segno facoltativo. Il segno può essere visualizzato all'inizio di s se style include il flag di NumberStyles.AllowLeadingSign e può essere visualizzato alla fine di s se style include il flag NumberStyles.AllowTrailingSign. Le parentesi possono essere usate in s per indicare un valore negativo se style include il flag NumberStyles.AllowParentheses.
cifre	Sequenza di cifre da 0 a 9.
.	Simbolo di virgola decimale specifica delle impostazioni cultura. Il simbolo decimale delle impostazioni cultura corrente può essere visualizzato in s se style include il flag NumberStyles.AllowDecimalPoint.
fractional_digits	Una o più occorrenze della cifra 0-9 se style include il flag di NumberStyles.AllowExponent o una o più occorrenze della cifra 0 in caso contrario. Le cifre frazionarie possono essere visualizzate in s 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 s può rappresentare un numero in notazione esponenziale se style include il flag NumberStyles.AllowExponent.
exponential_digits	Una o più occorrenze della cifra 0-9. Il parametro s 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 allo stile di NumberStyles.None) viene sempre analizzata correttamente. La maggior parte dei rimanenti NumberStyles membri controlli elementi che possono essere presenti, ma non devono essere presenti, nella stringa di input. La tabella seguente indica in che modo i singoli membri NumberStyles influiscono sugli elementi che possono essere presenti in s.

Valori NumberStyles non compositi	Elementi consentiti nei oltre alle cifre
NumberStyles.None	Solo cifre decimali.
NumberStyles.AllowDecimalPoint	Il separatore decimale (.) e gli elementi fractional_digits. Tuttavia, se style non include il flag NumberStyles.AllowExponent, fractional_digits deve essere costituito da una o più cifre 0; in caso contrario, viene generata una OverflowException.
NumberStyles.AllowExponent	Carattere "e" o "E", che indica la notazione esponenziale, insieme a exponential_digits.
NumberStyles.AllowLeadingWhite	Elemento ws all'inizio di .
NumberStyles.AllowTrailingWhite	Elemento ws alla fine di .
NumberStyles.AllowLeadingSign	Segno positivo prima di cifre.
NumberStyles.AllowTrailingSign	Segno positivo dopo cifre.
NumberStyles.AllowParentheses	Elemento segno sotto forma di parentesi che racchiudono il valore numerico.
NumberStyles.AllowThousands	Elemento separatore di gruppo (,). Anche se il separatore di gruppo può essere visualizzato in s, deve essere preceduto da una o più cifre 0.
NumberStyles.AllowCurrencySymbol	Elemento currency ($).

Se viene usato il flag NumberStyles.AllowHexSpecifier, s deve essere un valore esadecimale. Le cifre esadecimali valide sono 0-9, a-f e A-F. Un prefisso come "0x" non è supportato e causa l'esito negativo dell'operazione di analisi. Gli unici flag che possono essere combinati inclusi in style sono NumberStyles.AllowLeadingWhite e NumberStyles.AllowTrailingWhite. L'enumerazione NumberStyles include uno stile numerico composito, NumberStyles.HexNumber, che include entrambi i flag di spazio vuoto.

Nota

Se il parametro s è la rappresentazione di stringa di un numero esadecimale, non può essere preceduto da alcuna decorazione (ad esempio 0x o &h) che la differenzia come numero esadecimale. In questo modo, l'operazione di analisi genera un'eccezione.

Se s rappresenta un numero esadecimale, il metodo Parse(String, NumberStyles) interpreta il bit di ordine elevato del byte come bit di segno.

Il parametro s viene analizzato usando le informazioni di formattazione in un oggetto NumberFormatInfo inizializzato per le impostazioni cultura di sistema correnti. Per usare le informazioni di formattazione di altre impostazioni cultura, chiamare l'overload Parse(String, NumberStyles, IFormatProvider).

Vedi anche

• ToString()
• TryParse
• l'analisi di stringhe numeriche in .NET
• Tipi di formattazione in .NET