SByte.Parse Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Converte la rappresentazione di stringa di un numero nell'equivalente intero con segno a 8 bit.
Overload
Parse(String, NumberStyles, IFormatProvider) |
Converte la rappresentazione in forma di stringa di un numero disponibile in uno stile precisato e in un formato specifico delle impostazioni cultura nell'equivalente intero con segno a 8 bit. |
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) |
Converte la rappresentazione intervallo di un numero espresso in uno stile precisato e in un formato specifico delle impostazioni cultura nell'equivalente intero 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 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
- Origine:
- SByte.cs
- Origine:
- SByte.cs
Importante
Questa API non è conforme a CLS.
- Alternativa conforme a CLS
- System.Int16.Parse(String, NumberStyles, IFormatProvider)
Converte la rappresentazione in forma di stringa di un numero disponibile in uno stile precisato e in un formato specifico delle impostazioni cultura nell'equivalente intero con segno a 8 bit.
public:
static System::SByte Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider);
public:
static System::SByte Parse(System::String ^ s, System::Globalization::NumberStyles style, IFormatProvider ^ provider) = System::Numerics::INumberBase<System::SByte>::Parse;
[System.CLSCompliant(false)]
public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider provider);
public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
[System.CLSCompliant(false)]
public static sbyte Parse (string s, System.Globalization.NumberStyles style, IFormatProvider? provider);
[<System.CLSCompliant(false)>]
static member Parse : string * System.Globalization.NumberStyles * IFormatProvider -> sbyte
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 che contiene il numero da convertire. Per interpretare la stringa, viene usato 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 relativamente a s
. Se provider
è null
, verranno usate le impostazioni cultura correnti del thread.
Restituisce
Valore di byte con segno a 8 bit equivalente al numero specificato nel parametro s
.
Implementazioni
- Attributi
Eccezioni
style
non è un valore di NumberStyles.
-oppure-
style
non è una combinazione di AllowHexSpecifier e HexNumber.
s
è null
.
Il formato di s
non è conforme a style
.
s
rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue.
-oppure-
s
include cifre frazionarie diverse da zero.
Esempio
Nell'esempio seguente viene illustrato l'uso del Parse(String, NumberStyles, IFormatProvider) metodo 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 style
parametro definisce gli elementi di stile,ad esempio lo spazio vuoto o il simbolo di segno positivo o negativo, consentiti nel s
parametro 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 s
parametro può includere gli elementi seguenti:
[ws] [$][sign]digits[.fractional_digits][E[sign]exponential_digits][ws]
Se style
include AllowHexSpecifier, il s
parametro può includere gli elementi seguenti:
[ws] hexdigits[ws]
Gli elementi tra parentesi quadre ([e]) sono facoltativi. La tabella seguente descrive i singoli elementi.
Elemento | Descrizione |
---|---|
ws | Spazio vuoto facoltativo. Gli spazi vuoti possono essere visualizzati all'inizio di s se include il NumberStyles.AllowLeadingWhite flag e possono essere visualizzati alla fine di s se style include il NumberStyles.AllowTrailingWhite flag .style |
$ | Simbolo di valuta specifico delle impostazioni cultura. La posizione nella stringa è definita dalla NumberFormatInfo.CurrencyPositivePattern proprietà delle impostazioni cultura correnti. Il simbolo di valuta delle impostazioni cultura correnti può essere visualizzato in s se style include il NumberStyles.AllowCurrencySymbol flag . |
sign | Segno facoltativo. Il segno può essere visualizzato all'inizio di s se include il NumberStyles.AllowLeadingSign flag e può apparire la fine di s se style include il NumberStyles.AllowTrailingSignstyle flag . Le parentesi possono essere usate in s per indicare un valore negativo se style include il NumberStyles.AllowParentheses flag . |
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 NumberStyles.AllowDecimalPoint flag . |
Cifre_frazionarie | Una o più occorrenze della cifra 0-9 se style include il NumberStyles.AllowExponent flag o una o più occorrenze della cifra 0, se non lo fa. Le cifre frazionarie possono essere visualizzate solo s se style include il NumberStyles.AllowDecimalPoint flag . |
E | Carattere "e" o "E", che indica che il valore è rappresentato nella notazione esponenziale (scientifica). Il s parametro può rappresentare un numero in notazione esponenziale se style include il NumberStyles.AllowExponent flag . |
exponential_digits | Sequenza di cifre da 0 a 9. Il s parametro può rappresentare un numero in notazione esponenziale se style include il NumberStyles.AllowExponent flag . |
hexdigits | Sequenza di cifre esadecimali da 0 a f o da 0 a F. |
Nota
Qualsiasi carattere NUL di terminazione (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 NumberStyles.None stile) analizza sempre correttamente. La maggior parte degli elementi di controllo membri rimanenti NumberStyles che possono essere presenti, ma non devono essere presenti, in questa stringa di input. La tabella seguente indica in che modo i singoli NumberStyles membri influiscono sugli elementi che possono essere presenti in s
.
Valori non compositi NumberStyles |
Elementi consentiti oltre s alle cifre |
---|---|
NumberStyles.None | Solo cifre decimali. |
NumberStyles.AllowDecimalPoint | Il separatore decimale (.) e gli elementi fractional_digits . Tuttavia, se lo stile non include il NumberStyles.AllowExponent flag, fractional_digits deve essere costituito da una o più cifre 0; in caso contrario, viene generata un'eccezione OverflowException . |
NumberStyles.AllowExponent | Carattere "e" o "E", che indica la notazione esponenziale, insieme a exponential_digits. |
NumberStyles.AllowLeadingWhite | Elemento ws all'inizio di s . |
NumberStyles.AllowTrailingWhite | Elemento ws alla fine di s . |
NumberStyles.AllowLeadingSign | Segno positivo prima delle cifre. |
NumberStyles.AllowTrailingSign | Segno positivo dopo le cifre. |
NumberStyles.AllowParentheses | Parentesi prima e dopo le 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 NumberStyles.AllowHexSpecifier flag, 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 s
parametro è 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 Parse(String, NumberStyles) metodo interpreta il bit di ordine elevato del byte come bit di segno.
Il provider
parametro è un'implementazione IFormatProvider il cui GetFormat metodo restituisce un NumberFormatInfo oggetto che fornisce informazioni specifiche delle impostazioni cultura sul formato di s
. Esistono tre modi per usare il provider
parametro per fornire informazioni di formattazione personalizzate all'operazione di analisi:
È possibile passare l'oggetto effettivo NumberFormatInfo che fornisce informazioni di formattazione. La sua implementazione di GetFormat restituisce semplicemente se stessa.
È possibile passare un CultureInfo oggetto che specifica le impostazioni cultura di cui utilizzare la formattazione. La proprietà NumberFormat fornisce informazioni di formattazione.
È possibile passare un'implementazione personalizzata IFormatProvider . 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.
Si applica a
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
- Origine:
- SByte.cs
- Origine:
- SByte.cs
- Origine:
- SByte.cs
Importante
Questa API non è conforme a CLS.
Converte la rappresentazione intervallo di un numero espresso in uno stile precisato e in un formato specifico delle impostazioni cultura nell'equivalente intero con segno a 8 bit.
public static sbyte Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider? provider = default);
[System.CLSCompliant(false)]
public static sbyte Parse (ReadOnlySpan<char> s, System.Globalization.NumberStyles style = System.Globalization.NumberStyles.Integer, IFormatProvider provider = default);
[System.CLSCompliant(false)]
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
[<System.CLSCompliant(false)>]
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. Per interpretare l'intervallo viene usato 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 relativamente a s
. Se provider
è null
, verranno usate le impostazioni cultura correnti del thread.
Restituisce
Valore di byte con segno a 8 bit equivalente al numero specificato nel parametro s
.
Implementazioni
- Attributi
Si applica a
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)
- Origine:
- SByte.cs
- 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 relative a utf8Text
.
Restituisce
Risultato dell'analisi utf8Text
di .
Implementazioni
Si applica a
Parse(String, IFormatProvider)
- Origine:
- SByte.cs
- Origine:
- SByte.cs
- Origine:
- SByte.cs
Converte la rappresentazione di stringa di un numero in un formato specifico delle impostazioni cultura nell'equivalente intero con segno a 8 bit.
public:
static System::SByte Parse(System::String ^ s, IFormatProvider ^ provider);
public:
static System::SByte Parse(System::String ^ s, IFormatProvider ^ provider) = IParsable<System::SByte>::Parse;
[System.CLSCompliant(false)]
public static sbyte Parse (string s, IFormatProvider provider);
public static sbyte Parse (string s, IFormatProvider? provider);
[System.CLSCompliant(false)]
public static sbyte Parse (string s, IFormatProvider? provider);
[<System.CLSCompliant(false)>]
static member Parse : string * IFormatProvider -> sbyte
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. Per interpretare la stringa, viene usato lo stile Integer.
- provider
- IFormatProvider
Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura relativamente a s
. Se provider
è null
, verranno usate le impostazioni cultura correnti del thread.
Restituisce
Intero con segno a 8 bit equivalente al numero specificato in s
.
Implementazioni
- Attributi
Eccezioni
s
è null
.
Il formato di s
non è corretto.
s
rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue.
Esempio
Nell'esempio seguente viene definito un oggetto personalizzato NumberFormatInfo che definisce la tilde (~) come segno negativo. Analizza quindi una serie di stringhe numeriche usando questo oggetto personalizzato NumberFormatInfo e un CultureInfo oggetto 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 s
parametro contiene un numero di form:
[ws] [sign] digits[ws]
Gli elementi tra parentesi quadre ([e]) sono facoltativi. La tabella seguente descrive i singoli elementi.
Elemento | Descrizione |
---|---|
ws | Spazio vuoto facoltativo. |
sign | Segno facoltativo. |
Cifre | Sequenza di cifre compresa tra 0 e 9. |
Il s
parametro viene interpretato usando lo Integer stile . Oltre alle cifre decimali del valore byte, sono consentiti solo 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 Parse(String, NumberStyles, IFormatProvider) metodo .
Il provider
parametro è un'implementazione IFormatProvider il cui GetFormat metodo restituisce un NumberFormatInfo oggetto che fornisce informazioni specifiche delle impostazioni cultura sul formato di s
. Esistono tre modi per usare il provider
parametro per fornire informazioni di formattazione personalizzate all'operazione di analisi:
È possibile passare l'oggetto effettivo NumberFormatInfo che fornisce informazioni di formattazione. La sua implementazione di GetFormat restituisce semplicemente se stessa.
È possibile passare un CultureInfo oggetto che specifica le impostazioni cultura di cui utilizzare la formattazione. La proprietà NumberFormat fornisce informazioni di formattazione.
È possibile passare un'implementazione personalizzata IFormatProvider . 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
Si applica a
Parse(String)
- Origine:
- SByte.cs
- Origine:
- SByte.cs
- Origine:
- SByte.cs
Converte la rappresentazione di stringa di un numero nell'equivalente intero con segno a 8 bit.
public:
static System::SByte Parse(System::String ^ s);
[System.CLSCompliant(false)]
public static sbyte Parse (string s);
public static sbyte Parse (string s);
[<System.CLSCompliant(false)>]
static member Parse : string -> sbyte
static member Parse : string -> sbyte
Public Shared Function Parse (s As String) As SByte
Parametri
- s
- String
Stringa che rappresenta un numero da convertire. Per interpretare la stringa, viene usato lo stile Integer.
Restituisce
Intero con segno a 8 bit equivalente al numero specificato nel parametro s
.
- Attributi
Eccezioni
s
è null
.
L'oggetto s
non è costituito da un segno facoltativo seguito da una sequenza di cifre (da 0 a 9).
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 byte firmato usando il Parse metodo . 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 s
parametro contiene un numero di form:
[ws] [sign] digits[ws]
Gli elementi tra parentesi quadre ([e]) sono facoltativi. La tabella seguente descrive i singoli elementi.
Elemento | Descrizione |
---|---|
ws | Spazio vuoto facoltativo. |
sign | Segno facoltativo. |
Cifre | Sequenza di cifre compresa tra 0 e 9. |
Il s
parametro viene interpretato usando lo NumberStyles.Integer stile . Oltre alle cifre decimali del valore 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
, usare il Parse(String, NumberStyles) metodo o Parse(String, NumberStyles, IFormatProvider) .
Il s
parametro viene analizzato usando le informazioni di formattazione in un NumberFormatInfo oggetto 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 Parse(String, NumberStyles, IFormatProvider) metodo .
Vedi anche
Si applica a
Parse(ReadOnlySpan<Char>, IFormatProvider)
- Origine:
- SByte.cs
- Origine:
- SByte.cs
- 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 relative a s
.
Restituisce
Risultato dell'analisi s
di .
Implementazioni
Si applica a
Parse(ReadOnlySpan<Byte>, IFormatProvider)
- Origine:
- SByte.cs
- 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 relative a utf8Text
.
Restituisce
Risultato dell'analisi utf8Text
di .
Implementazioni
Si applica a
Parse(String, NumberStyles)
- Origine:
- SByte.cs
- Origine:
- SByte.cs
- Origine:
- SByte.cs
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);
[System.CLSCompliant(false)]
public static sbyte Parse (string s, System.Globalization.NumberStyles style);
public static sbyte Parse (string s, System.Globalization.NumberStyles style);
[<System.CLSCompliant(false)>]
static member Parse : string * System.Globalization.NumberStyles -> sbyte
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 interpreta 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
Intero con segno a 8 bit equivalente al numero specificato in s
.
- Attributi
Eccezioni
s
è null
.
Il formato di s
non è conforme a style
.
s
rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue.
-oppure-
s
include cifre frazionarie diverse da zero.
style
non è un valore di NumberStyles.
-oppure-
style
non è una combinazione di valori di AllowHexSpecifier e HexNumber.
Esempio
Nell'esempio seguente vengono analizzate le rappresentazioni di stringa dei SByte valori con il Parse(String, NumberStyles) metodo . 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 style
parametro definisce gli elementi di stile,ad esempio lo spazio vuoto o il simbolo di segno positivo o negativo, consentiti nel s
parametro 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 s
parametro può includere gli elementi seguenti:
[ws] [$][sign]digits[.fractional_digits][E[sign]exponential_digits][ws]
Se style
include NumberStyles.AllowHexSpecifier, il s
parametro può contenere gli elementi seguenti:
[ws] hexdigits[ws]
Gli elementi tra parentesi quadre ([e]) sono facoltativi. La tabella seguente descrive i singoli elementi.
Elemento | Descrizione |
---|---|
ws | Spazio vuoto facoltativo. Gli spazi vuoti possono essere visualizzati all'inizio di s se include il NumberStyles.AllowLeadingWhite flag e possono essere visualizzati alla fine di s se lo stile include il NumberStyles.AllowTrailingWhitestyle flag. |
$ | Simbolo di valuta specifico delle impostazioni cultura. La posizione nella stringa è definita dalla NumberFormatInfo.CurrencyPositivePattern proprietà delle impostazioni cultura correnti. Il simbolo di valuta delle impostazioni cultura correnti può essere visualizzato in s se style include il NumberStyles.AllowCurrencySymbol flag . |
sign | Segno facoltativo. Il segno può essere visualizzato all'inizio di s se include il NumberStyles.AllowLeadingSign flag e può essere visualizzato alla fine di s se style include il NumberStyles.AllowTrailingSignstyle flag . Le parentesi possono essere usate in s per indicare un valore negativo se style include il NumberStyles.AllowParentheses flag . |
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 NumberStyles.AllowDecimalPoint flag . |
Cifre_frazionarie | Una o più occorrenze della cifra 0-9 se style include il NumberStyles.AllowExponent flag o una o più occorrenze della cifra 0, se non lo fa. Le cifre frazionarie possono essere visualizzate solo s se style include il NumberStyles.AllowDecimalPoint flag . |
E | Carattere "e" o "E", che indica che il valore è rappresentato nella notazione esponenziale (scientifica). Il s parametro può rappresentare un numero in notazione esponenziale se style include il NumberStyles.AllowExponent flag . |
exponential_digits | Una o più occorrenze della cifra 0-9. Il s parametro può rappresentare un numero in notazione esponenziale se style include il NumberStyles.AllowExponent flag . |
hexdigits | Sequenza di cifre esadecimali da 0 a f o da 0 a F. |
Nota
Qualsiasi carattere NUL di terminazione (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 NumberStyles.None stile) analizza sempre correttamente. La maggior parte degli elementi di controllo membri rimanenti NumberStyles che possono essere presenti, ma non devono essere presenti, nella stringa di input. La tabella seguente indica in che modo i singoli NumberStyles membri influiscono sugli elementi che possono essere presenti in s
.
Valori 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 style non include il NumberStyles.AllowExponent flag, fractional_digits deve essere costituito da una o più cifre 0; in caso contrario, viene generata un'eccezione OverflowException . |
NumberStyles.AllowExponent | Carattere "e" o "E", che indica la notazione esponenziale, insieme a exponential_digits. |
NumberStyles.AllowLeadingWhite | Elemento ws all'inizio di s . |
NumberStyles.AllowTrailingWhite | Elemento ws alla fine di s . |
NumberStyles.AllowLeadingSign | Segno positivo prima delle cifre. |
NumberStyles.AllowTrailingSign | Segno positivo dopo le cifre. |
NumberStyles.AllowParentheses | Elemento di segno sotto forma di parentesi che racchiude 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 NumberStyles.AllowHexSpecifier flag, s
deve essere un valore esadecimale. Le cifre esadecimali valide sono 0-9, a-f e A-F. Un prefisso, ad esempio "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 s
parametro è 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 Parse(String, NumberStyles) metodo interpreta il bit di ordine elevato del byte come bit di segno.
Il s
parametro viene analizzato usando le informazioni di formattazione in un NumberFormatInfo oggetto 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
Si applica a
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per