Convert.ToSByte 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 un valore specificato in un intero con segno a 8 bit.
Overload
| ToSByte(SByte) |
Restituisce l'intero con segno a 8 bit specificato; non viene eseguita alcuna conversione effettiva. |
| ToSByte(String, Int32) |
Converte la rappresentazione di stringa di un numero in una base specificata nell'intero con segno a 8 bit equivalente. |
| ToSByte(String, IFormatProvider) |
Converte la rappresentazione di stringa specificata di un numero in un intero con segno a 8 bit equivalente mediante le informazioni di formattazione specifiche delle impostazioni cultura indicate. |
| ToSByte(Object, IFormatProvider) |
Converte il valore dell'oggetto specificato in un intero con segno a 8 bit mediante le informazioni di formattazione specifiche delle impostazioni cultura indicate. |
| ToSByte(UInt64) |
Converte il valore dell'intero senza segno a 64 bit specificato in un intero con segno a 8 bit equivalente. |
| ToSByte(UInt32) |
Converte il valore dell'intero senza segno a 32 bit specificato in un intero con segno a 8 bit equivalente. |
| ToSByte(String) |
Converte la rappresentazione di stringa specificata di un numero in un intero con segno a 8 bit equivalente. |
| ToSByte(Single) |
Converte il valore del numero a virgola mobile e con precisione singola specificato in un intero con segno a 8 bit equivalente. |
| ToSByte(Object) |
Converte il valore dell'oggetto specificato in un intero con segno a 8 bit. |
| ToSByte(UInt16) |
Converte il valore dell'intero senza segno a 16 bit specificato nell'intero con segno a 8 bit equivalente. |
| ToSByte(Int32) |
Converte il valore dell'intero con segno a 32 bit specificato in un intero con segno a 8 bit equivalente. |
| ToSByte(Int64) |
Converte il valore dell'intero con segno a 64 bit specificato in un intero con segno a 8 bit equivalente. |
| ToSByte(Byte) |
Converte il valore dell'intero senza segno a 8 bit specificato nell'intero con segno a 8 bit equivalente. |
| ToSByte(Char) |
Converte il valore del carattere Unicode specificato nell'intero con segno a 8 bit equivalente. |
| ToSByte(DateTime) |
La chiamata di questo metodo genera sempre un'eccezione InvalidCastException. |
| ToSByte(Boolean) |
Converte il valore booleano specificato nell'intero con segno a 8 bit equivalente. |
| ToSByte(Double) |
Converte il valore del numero a virgola mobile e con precisione doppia specificato in un intero con segno a 8 bit equivalente. |
| ToSByte(Int16) |
Converte il valore dell'intero con segno a 16 bit specificato nell'intero con segno a 8 bit equivalente. |
| ToSByte(Decimal) |
Converte il valore del numero decimale specificato in un intero con segno a 8 bit equivalente. |
ToSByte(SByte)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Restituisce l'intero con segno a 8 bit specificato; non viene eseguita alcuna conversione effettiva.
public:
static System::SByte ToSByte(System::SByte value);[System.CLSCompliant(false)]
public static sbyte ToSByte (sbyte value);[<System.CLSCompliant(false)>]
static member ToSByte : sbyte -> sbytePublic Shared Function ToSByte (value As SByte) As SByteParametri
- value
- SByte
Intero con segno a 8 bit da restituire.
Restituisce
value viene restituito invariato.
- Attributi
Si applica a
ToSByte(String, Int32)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte la rappresentazione di stringa di un numero in una base specificata nell'intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(System::String ^ value, int fromBase);[System.CLSCompliant(false)]
public static sbyte ToSByte (string value, int fromBase);[System.CLSCompliant(false)]
public static sbyte ToSByte (string? value, int fromBase);[<System.CLSCompliant(false)>]
static member ToSByte : string * int -> sbytePublic Shared Function ToSByte (value As String, fromBase As Integer) As SByteParametri
- value
- String
Stringa che contiene il numero da convertire.
- fromBase
- Int32
Base del numero in value, che deve essere 2, 8, 10 o 16.
Restituisce
Intero con segno a 8 bit equivalente al numero in value oppure 0 (zero) se value è null.
- Attributi
Eccezioni
Il valore di fromBase non è 2, 8, 10 o 16.
-oppure-
value, che rappresenta un numero con segno non in base 10, è preceduto da un segno negativo.
value è Empty.
value contiene un carattere che corrisponde a una cifra non valida nella base specificata da fromBase. Il messaggio di eccezione indica che non ci sono cifre da convertire se il primo carattere in value non è valido; in caso contrario, il messaggio indica che value contiene caratteri finali non validi.
value, che rappresenta un numero con segno non in base 10, è preceduto da un segno negativo.
-oppure-
value rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue.
Esempio
Nell'esempio seguente viene tentato di interpretare gli elementi in una matrice di stringhe come rappresentazione binaria, ottale ed esadecimale dei valori numerici per convertirli in byte senza segno.
using System;
public class Example
{
public static void Main()
{
int[] baseValues = { 2, 8, 16};
string[] values = { "FF", "81", "03", "11", "8F", "01", "1C", "111",
"123", "18A" };
// Convert to each supported base.
foreach (int baseValue in baseValues)
{
Console.WriteLine("Converting strings in base {0}:", baseValue);
foreach (string value in values)
{
Console.Write(" '{0,-5} --> ", value + "'");
try {
Console.WriteLine(Convert.ToSByte(value, baseValue));
}
catch (FormatException) {
Console.WriteLine("Bad Format");
}
catch (OverflowException) {
Console.WriteLine("Out of Range");
}
}
Console.WriteLine();
}
}
}
// The example displays the following output:
// Converting strings in base 2:
// 'FF' --> Bad Format
// '81' --> Bad Format
// '03' --> Bad Format
// '11' --> 3
// '8F' --> Bad Format
// '01' --> 1
// '1C' --> Bad Format
// '111' --> 7
// '123' --> Bad Format
// '18A' --> Bad Format
//
// Converting strings in base 8:
// 'FF' --> Bad Format
// '81' --> Bad Format
// '03' --> 3
// '11' --> 9
// '8F' --> Bad Format
// '01' --> 1
// '1C' --> Bad Format
// '111' --> 73
// '123' --> 83
// '18A' --> Bad Format
//
// Converting strings in base 16:
// 'FF' --> -1
// '81' --> -127
// '03' --> 3
// '11' --> 17
// '8F' --> -113
// '01' --> 1
// '1C' --> 28
// '111' --> Out of Range
// '123' --> Out of Range
// '18A' --> Out of Range
open System
let baseValues =
[| 2; 8; 16 |]
let values =
[| "FF"; "81"; "03"; "11"; "8F"; "01"; "1C"; "111"; "123"; "18A" |]
// Convert to each supported base.
for baseValue in baseValues do
printfn $"Converting strings in base {baseValue}:"
for value in values do
printf $""" '{value + "'",-5} --> """
try
printfn $"{Convert.ToSByte(value, baseValue)}"
with
| :? FormatException ->
printfn "Bad Format"
| :? OverflowException ->
printfn "Out of Range"
printfn ""
// The example displays the following output:
// Converting strings in base 2:
// 'FF' --> Bad Format
// '81' --> Bad Format
// '03' --> Bad Format
// '11' --> 3
// '8F' --> Bad Format
// '01' --> 1
// '1C' --> Bad Format
// '111' --> 7
// '123' --> Bad Format
// '18A' --> Bad Format
//
// Converting strings in base 8:
// 'FF' --> Bad Format
// '81' --> Bad Format
// '03' --> 3
// '11' --> 9
// '8F' --> Bad Format
// '01' --> 1
// '1C' --> Bad Format
// '111' --> 73
// '123' --> 83
// '18A' --> Bad Format
//
// Converting strings in base 16:
// 'FF' --> -1
// '81' --> -127
// '03' --> 3
// '11' --> 17
// '8F' --> -113
// '01' --> 1
// '1C' --> 28
// '111' --> Out of Range
// '123' --> Out of Range
// '18A' --> Out of Range
Module Example
Public Sub Main()
Dim bases() As Integer = { 2, 8, 16}
Dim values() As String = { "FF", "81", "03", "11", "8F", "01", "1C", _
"111", "123", "18A" }
' Convert to each supported base.
For Each base As Integer In bases
Console.WriteLine("Converting strings in base {0}:", base)
For Each value As String In values
Console.Write(" '{0,-5} --> ", value + "'")
Try
Console.WriteLine(Convert.ToSByte(value, base))
Catch e As FormatException
Console.WriteLine("Bad Format")
Catch e As OverflowException
Console.WriteLine("Out of Range")
End Try
Next
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' Converting strings in base 2:
' 'FF' --> Bad Format
' '81' --> Bad Format
' '03' --> Bad Format
' '11' --> 3
' '8F' --> Bad Format
' '01' --> 1
' '1C' --> Bad Format
' '111' --> 7
' '123' --> Bad Format
' '18A' --> Bad Format
'
' Converting strings in base 8:
' 'FF' --> Bad Format
' '81' --> Bad Format
' '03' --> 3
' '11' --> 9
' '8F' --> Bad Format
' '01' --> 1
' '1C' --> Bad Format
' '111' --> 73
' '123' --> 83
' '18A' --> Bad Format
'
' Converting strings in base 16:
' 'FF' --> -1
' '81' --> -127
' '03' --> 3
' '11' --> 17
' '8F' --> -113
' '01' --> 1
' '1C' --> 28
' '111' --> Out of Range
' '123' --> Out of Range
' '18A' --> Out of Range
Commenti
Se fromBase è 16, è possibile prefisso il numero specificato dal value parametro con "0x" o "0X".
Poiché il segno negativo non è supportato per rappresentazioni numeriche non di base 10, il ToSByte(String, Int32) metodo presuppone che i numeri negativi usino la rappresentazione di complemento di due. In altre parole, il metodo interpreta sempre il bit di ordine elevato di un byte (bit 7) come bit di segno. Di conseguenza, è possibile scrivere codice in cui un numero non di base 10 non compreso nell'intervallo del SByte tipo di dati viene convertito in un SByte valore senza che il metodo generi un'eccezione. Nell'esempio seguente viene eseguita la conversione MaxValue nella rappresentazione stringa esadecimale e quindi viene chiamato il ToSByte(String, Int32) metodo . Anziché generare un'eccezione, il metodo visualizza il messaggio "0xff converte in -1".
// Create a hexadecimal value out of range of the SByte type.
string value = Convert.ToString(byte.MaxValue, 16);
// Convert it back to a number.
try
{
sbyte number = Convert.ToSByte(value, 16);
Console.WriteLine("0x{0} converts to {1}.", value, number);
}
catch (OverflowException)
{
Console.WriteLine("Unable to convert '0x{0}' to a signed byte.", value);
}
// Create a hexadecimal value out of range of the SByte type.
let value = Convert.ToString(Byte.MaxValue, 16)
// Convert it back to a number.
try
let number = Convert.ToSByte(value, 16)
printfn $"0x{value} converts to {number}."
with :? OverflowException ->
printfn $"Unable to convert '0x{value}' to a signed byte."
' Create a hexadecimal value out of range of the SByte type.
Dim value As String = Convert.ToString(Byte.MaxValue, 16)
' Convert it back to a number.
Try
Dim number As SByte = Convert.ToSByte(value, 16)
Console.WriteLine("0x{0} converts to {1}.", value, number)
Catch e As OverflowException
Console.WriteLine("Unable to convert '0x{0}' to a signed byte.", value)
End Try
Quando si eseguono operazioni binarie o conversioni numeriche, è sempre responsabilità dello sviluppatore verificare che un metodo usi la rappresentazione numerica appropriata per interpretare un determinato valore. Come illustrato nell'esempio seguente, è possibile assicurarsi che il metodo gestisca correttamente i overflow determinando prima se un valore rappresenta un tipo non firmato o firmato durante la conversione nella rappresentazione stringa esadecimale. Generare un'eccezione se il valore originale è un tipo non firmato, ma la conversione torna a un byte firmato restituisce un valore il cui bit di segno è attivo.
// Create a hexadecimal value out of range of the SByte type.
byte sourceNumber = byte.MaxValue;
bool isSigned = Math.Sign(Convert.ToDouble(sourceNumber.GetType().GetField("MinValue").GetValue(null))) == -1;
string value = Convert.ToString(sourceNumber, 16);
sbyte targetNumber;
try
{
targetNumber = Convert.ToSByte(value, 16);
if (! isSigned && ((targetNumber & 0x80) != 0))
throw new OverflowException();
else
Console.WriteLine("0x{0} converts to {1}.", value, targetNumber);
}
catch (OverflowException)
{
Console.WriteLine("Unable to convert '0x{0}' to a signed byte.", value);
}
// Displays the following to the console:
// Unable to convert '0xff' to a signed byte.
// Create a hexadecimal value out of range of the SByte type.
let sourceNumber = Byte.MaxValue
let isSigned = sign (Convert.ToDouble(sourceNumber.GetType().GetField("MinValue").GetValue null)) = -1
let value = Convert.ToString(sourceNumber, 16)
try
let targetNumber = Convert.ToSByte(value, 16)
if not isSigned && targetNumber &&& 0x80y <> 0y then
raise (OverflowException())
else
printfn $"0x{value} converts to {targetNumber}."
with :? OverflowException ->
printfn $"Unable to convert '0x{value}' to a signed byte."
// Displays the following to the console:
// Unable to convert '0xff' to a signed byte.
' Create a negative hexadecimal value out of range of the Long type.
Dim sourceNumber As Byte = Byte.MaxValue
Dim isSigned As Boolean = Math.Sign(sourceNumber.MinValue) = -1
Dim value As String = Convert.ToString(sourceNumber, 16)
Dim targetNumber As SByte
Try
targetNumber = Convert.ToSByte(value, 16)
If Not isSigned And ((targetNumber And &H80) <> 0) Then
Throw New OverflowException()
Else
Console.WriteLine("0x{0} converts to {1}.", value, targetNumber)
End If
Catch e As OverflowException
Console.WriteLine("Unable to convert '0x{0}' to a signed byte.", value)
End Try
' Displays the following to the console:
' Unable to convert '0xff' to a signed byte.
Si applica a
ToSByte(String, IFormatProvider)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte la rappresentazione di stringa specificata di un numero in un intero con segno a 8 bit equivalente mediante le informazioni di formattazione specifiche delle impostazioni cultura indicate.
public:
static System::SByte ToSByte(System::String ^ value, IFormatProvider ^ provider);[System.CLSCompliant(false)]
public static sbyte ToSByte (string value, IFormatProvider provider);[System.CLSCompliant(false)]
public static sbyte ToSByte (string value, IFormatProvider? provider);[<System.CLSCompliant(false)>]
static member ToSByte : string * IFormatProvider -> sbytePublic Shared Function ToSByte (value As String, provider As IFormatProvider) As SByteParametri
- value
- String
Stringa che contiene il numero da convertire.
- provider
- IFormatProvider
Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.
Restituisce
Intero con segno a 8 bit equivalente a value.
- Attributi
Eccezioni
value è null.
value non è costituito da un segno facoltativo seguito da una sequenza di cifre (da 0 a 9).
value rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue.
Esempio
L'esempio seguente converte le rappresentazioni di stringa dei SByte valori con il ToSByte metodo usando un IFormatProvider oggetto .
// Example of the Convert::ToSByte( String* ) and
// Convert::ToSByte( String*, IFormatProvider* ) methods.
using namespace System;
using namespace System::Globalization;
const __wchar_t * protoFmt = L"{0,-20}{1,-20}{2}";
// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}
void ConvertToSByte( String^ numericStr, IFormatProvider^ provider )
{
Object^ defaultValue;
Object^ providerValue;
// Convert numericStr to SByte without a format provider.
try
{
defaultValue = Convert::ToSByte( numericStr );
}
catch ( Exception^ ex )
{
defaultValue = GetExceptionType( ex );
}
// Convert numericStr to SByte with a format provider.
try
{
providerValue = Convert::ToSByte( numericStr, provider );
}
catch ( Exception^ ex )
{
providerValue = GetExceptionType( ex );
}
Console::WriteLine( gcnew String( protoFmt ), numericStr, defaultValue, providerValue );
}
int main()
{
// Create a NumberFormatInfo object and set several of its
// properties that apply to numbers.
NumberFormatInfo^ provider = gcnew NumberFormatInfo;
// These properties affect the conversion.
provider->NegativeSign = "neg ";
provider->PositiveSign = "pos ";
// These properties do not affect the conversion.
// The input string cannot have decimal and group separators.
provider->NumberDecimalSeparator = ".";
provider->NumberNegativePattern = 0;
Console::WriteLine( "This example of\n"
" Convert::ToSByte( String* ) and \n"
" Convert::ToSByte( String*, IFormatProvider* ) "
"\ngenerates the following output. It converts "
"several strings to \nSByte values, using "
"default formatting or a NumberFormatInfo object.\n" );
Console::WriteLine( gcnew String( protoFmt ), "String to convert", "Default/exception", "Provider/exception" );
Console::WriteLine( gcnew String( protoFmt ), "-----------------", "-----------------", "------------------" );
// Convert strings, with and without an IFormatProvider.
ConvertToSByte( "123", provider );
ConvertToSByte( "+123", provider );
ConvertToSByte( "pos 123", provider );
ConvertToSByte( "-123", provider );
ConvertToSByte( "neg 123", provider );
ConvertToSByte( "123.", provider );
ConvertToSByte( "(123)", provider );
ConvertToSByte( "128", provider );
ConvertToSByte( "-129", provider );
}
/*
This example of
Convert::ToSByte( String* ) and
Convert::ToSByte( String*, IFormatProvider* )
generates the following output. It converts several strings to
SByte values, using default formatting or a NumberFormatInfo object.
String to convert Default/exception Provider/exception
----------------- ----------------- ------------------
123 123 123
+123 123 FormatException
pos 123 FormatException 123
-123 -123 FormatException
neg 123 FormatException -123
123. FormatException FormatException
(123) FormatException FormatException
128 OverflowException OverflowException
-129 OverflowException FormatException
*/
// Example of the Convert.ToSByte( string ) and
// Convert.ToSByte( string, IFormatProvider ) methods.
using System;
using System.Globalization;
class ToSByteProviderDemo
{
static string format = "{0,-20}{1,-20}{2}";
// Get the exception type name; remove the namespace prefix.
static string GetExceptionType( Exception ex )
{
string exceptionType = ex.GetType( ).ToString( );
return exceptionType.Substring(
exceptionType.LastIndexOf( '.' ) + 1 );
}
static void ConvertToSByte( string numericStr,
IFormatProvider provider )
{
object defaultValue;
object providerValue;
// Convert numericStr to SByte without a format provider.
try
{
defaultValue = Convert.ToSByte( numericStr );
}
catch( Exception ex )
{
defaultValue = GetExceptionType( ex );
}
// Convert numericStr to SByte with a format provider.
try
{
providerValue = Convert.ToSByte( numericStr, provider );
}
catch( Exception ex )
{
providerValue = GetExceptionType( ex );
}
Console.WriteLine( format, numericStr,
defaultValue, providerValue );
}
public static void Main( )
{
// Create a NumberFormatInfo object and set several of its
// properties that apply to numbers.
NumberFormatInfo provider = new NumberFormatInfo();
// These properties affect the conversion.
provider.NegativeSign = "neg ";
provider.PositiveSign = "pos ";
// These properties do not affect the conversion.
// The input string cannot have decimal and group separators.
provider.NumberDecimalSeparator = ".";
provider.NumberNegativePattern = 0;
Console.WriteLine("This example of\n" +
" Convert.ToSByte( string ) and \n" +
" Convert.ToSByte( string, IFormatProvider ) " +
"\ngenerates the following output. It converts " +
"several strings to \nSByte values, using " +
"default formatting or a NumberFormatInfo object.\n" );
Console.WriteLine( format, "String to convert",
"Default/exception", "Provider/exception" );
Console.WriteLine( format, "-----------------",
"-----------------", "------------------" );
// Convert strings, with and without an IFormatProvider.
ConvertToSByte( "123", provider );
ConvertToSByte( "+123", provider );
ConvertToSByte( "pos 123", provider );
ConvertToSByte( "-123", provider );
ConvertToSByte( "neg 123", provider );
ConvertToSByte( "123.", provider );
ConvertToSByte( "(123)", provider );
ConvertToSByte( "128", provider );
ConvertToSByte( "-129", provider );
}
}
/*
This example of
Convert.ToSByte( string ) and
Convert.ToSByte( string, IFormatProvider )
generates the following output. It converts several strings to
SByte values, using default formatting or a NumberFormatInfo object.
String to convert Default/exception Provider/exception
----------------- ----------------- ------------------
123 123 123
+123 123 FormatException
pos 123 FormatException 123
-123 -123 FormatException
neg 123 FormatException -123
123. FormatException FormatException
(123) FormatException FormatException
128 OverflowException OverflowException
-129 OverflowException FormatException
*/
// Example of the Convert.ToSByte( string ) and
// Convert.ToSByte( string, IFormatProvider ) methods.
open System
open System.Globalization
let format obj1 obj2 obj3 = printfn $"{obj1,-20}{obj2,-20}{obj3}"
// Get the exception type name; remove the namespace prefix.
let getExceptionType (ex: exn) =
let exceptionType = ex.GetType() |> string
exceptionType.Substring(exceptionType.LastIndexOf '.' + 1 )
let convertToSByte (numericStr: string) (provider: IFormatProvider) =
// Convert numericStr to SByte without a format provider.
let defaultValue =
try
Convert.ToSByte numericStr
|> string
with ex ->
getExceptionType ex
// Convert numericStr to SByte with a format provider.
let providerValue =
try
Convert.ToSByte(numericStr, provider)
|> string
with ex ->
getExceptionType ex
format numericStr defaultValue providerValue
// Create a NumberFormatInfo object and set several of its
// properties that apply to numbers.
let provider = NumberFormatInfo()
// These properties affect the conversion.
provider.NegativeSign <- "neg "
provider.PositiveSign <- "pos "
// These properties do not affect the conversion.
// The input string cannot have decimal and group separators.
provider.NumberDecimalSeparator <- "."
provider.NumberNegativePattern <- 0
printfn
"""This example of
Convert.ToSByte( string ) and
Convert.ToSByte( string, IFormatProvider )
generates the following output. It converts several strings to
SByte values, using default formatting or a NumberFormatInfo object.
"""
format "String to convert" "Default/exception" "Provider/exception"
format "-----------------" "-----------------" "------------------"
// Convert strings, with and without an IFormatProvider.
convertToSByte "123" provider
convertToSByte "+123" provider
convertToSByte "pos 123" provider
convertToSByte "-123" provider
convertToSByte "neg 123" provider
convertToSByte "123." provider
convertToSByte "(123)" provider
convertToSByte "128" provider
convertToSByte "-129" provider
// This example of
// Convert.ToSByte( string ) and
// Convert.ToSByte( string, IFormatProvider )
// generates the following output. It converts several strings to
// SByte values, using default formatting or a NumberFormatInfo object.
// String to convert Default/exception Provider/exception
// ----------------- ----------------- ------------------
// 123 123 123
// +123 123 FormatException
// pos 123 FormatException 123
// -123 -123 FormatException
// neg 123 FormatException -123
// 123. FormatException FormatException
// (123) FormatException FormatException
// 128 OverflowException OverflowException
// -129 OverflowException FormatException
' Example of the Convert.ToSByte( String ) and
' Convert.ToSByte( String, IFormatProvider ) methods.
Imports System.Globalization
Module ToSByteProviderDemo
Dim format As String = "{0,-20}{1,-20}{2}"
' Get the exception type name; remove the namespace prefix.
Function GetExceptionType( ex As Exception ) As String
Dim exceptionType As String = ex.GetType( ).ToString( )
Return exceptionType.Substring( _
exceptionType.LastIndexOf( "."c ) + 1 )
End Function
Sub ConvertToSByte( numericStr As String, _
provider As IFormatProvider )
Dim defaultValue As Object
Dim providerValue As Object
' Convert numericStr to SByte without a format provider.
Try
defaultValue = Convert.ToSByte( numericStr )
Catch ex As Exception
defaultValue = GetExceptionType( ex )
End Try
' Convert numericStr to SByte with a format provider.
Try
providerValue = Convert.ToSByte( numericStr, provider )
Catch ex As Exception
providerValue = GetExceptionType( ex )
End Try
Console.WriteLine( format, numericStr, _
defaultValue, providerValue )
End Sub
Sub Main( )
' Create a NumberFormatInfo object and set several of its
' properties that apply to numbers.
Dim provider As NumberFormatInfo = new NumberFormatInfo( )
' These properties affect the conversion.
provider.NegativeSign = "neg "
provider.PositiveSign = "pos "
' These properties do not affect the conversion.
' The input string cannot have decimal and group separators.
provider.NumberDecimalSeparator = "."
provider.NumberNegativePattern = 0
Console.WriteLine( "This example of" & vbCrLf & _
" Convert.ToSByte( String ) and " & vbCrLf & _
" Convert.ToSByte( String, IFormatProvider ) " & _
vbCrLf & "generates the following output. It " & _
"converts several strings to " & vbCrLf & "SByte " & _
"values, using default formatting " & _
"or a NumberFormatInfo object." & vbCrLf )
Console.WriteLine( format, "String to convert", _
"Default/exception", "Provider/exception" )
Console.WriteLine( format, "-----------------", _
"-----------------", "------------------" )
' Convert strings, with and without an IFormatProvider.
ConvertToSByte( "123", provider )
ConvertToSByte( "+123", provider )
ConvertToSByte( "pos 123", provider )
ConvertToSByte( "-123", provider )
ConvertToSByte( "neg 123", provider )
ConvertToSByte( "123.", provider )
ConvertToSByte( "(123)", provider )
ConvertToSByte( "128", provider )
ConvertToSByte( "-129", provider )
End Sub
End Module
' This example of
' Convert.ToSByte( String ) and
' Convert.ToSByte( String, IFormatProvider )
' generates the following output. It converts several strings to
' SByte values, using default formatting or a NumberFormatInfo object.
'
' String to convert Default/exception Provider/exception
' ----------------- ----------------- ------------------
' 123 123 123
' +123 123 FormatException
' pos 123 FormatException 123
' -123 -123 FormatException
' neg 123 FormatException -123
' 123. FormatException FormatException
' (123) FormatException FormatException
' 128 OverflowException OverflowException
' -129 OverflowException FormatException
Commenti
provider è un'istanza IFormatProvider che ottiene un NumberFormatInfo oggetto. L'oggetto NumberFormatInfo fornisce informazioni specifiche delle impostazioni cultura sul formato di value. Se provider è null, viene usato per NumberFormatInfo le impostazioni cultura correnti.
Se si preferisce non gestire un'eccezione se la conversione ha esito negativo, è possibile chiamare invece il SByte.TryParse metodo. Restituisce un Boolean valore che indica se la conversione ha avuto esito positivo o negativo.
Vedi anche
Si applica a
ToSByte(Object, IFormatProvider)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore dell'oggetto specificato in un intero con segno a 8 bit mediante le informazioni di formattazione specifiche delle impostazioni cultura indicate.
public:
static System::SByte ToSByte(System::Object ^ value, IFormatProvider ^ provider);[System.CLSCompliant(false)]
public static sbyte ToSByte (object value, IFormatProvider provider);[System.CLSCompliant(false)]
public static sbyte ToSByte (object? value, IFormatProvider? provider);[<System.CLSCompliant(false)>]
static member ToSByte : obj * IFormatProvider -> sbytePublic Shared Function ToSByte (value As Object, provider As IFormatProvider) As SByteParametri
- value
- Object
Oggetto che implementa l'interfaccia IConvertible.
- provider
- IFormatProvider
Oggetto che fornisce informazioni di formattazione specifiche delle impostazioni cultura.
Restituisce
Intero con segno a 8 bit equivalente a value oppure zero se value è null.
- Attributi
Eccezioni
Il formato di value non è appropriato.
value rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue.
Esempio
Nell'esempio seguente viene definita una classe che archivia byte firmati e senza segno come stringhe esadecimali insieme a un ByteString campo che indica il segno del byte. La classe ByteString implementa l'interfaccia IConvertible. Il IConvertible.ToSByte metodo chiama il Parse(String, IFormatProvider) metodo per eseguire la conversione. Se ha esito negativo, genera un OverflowExceptionoggetto .
using System;
using System.Globalization;
public enum SignBit { Negative=-1, Zero=0, Positive=1 };
public struct ByteString : IConvertible
{
private SignBit signBit;
private string byteString;
public SignBit Sign
{
set { signBit = value; }
get { return signBit; }
}
public string Value
{
set {
if (value.Trim().Length > 2)
throw new ArgumentException("The string representation of a byte cannot have more than two characters.");
else
byteString = value;
}
get { return byteString; }
}
// IConvertible implementations.
public TypeCode GetTypeCode() {
return TypeCode.Object;
}
public bool ToBoolean(IFormatProvider provider)
{
if (signBit == SignBit.Zero)
return false;
else
return true;
}
public byte ToByte(IFormatProvider provider)
{
if (signBit == SignBit.Negative)
throw new OverflowException(String.Format("{0} is out of range of the Byte type.", Convert.ToSByte(byteString, 16)));
else
return Byte.Parse(byteString, NumberStyles.HexNumber);
}
public char ToChar(IFormatProvider provider)
{
if (signBit == SignBit.Negative) {
throw new OverflowException(String.Format("{0} is out of range of the Char type.", Convert.ToSByte(byteString, 16)));
}
else {
byte byteValue = Byte.Parse(this.byteString, NumberStyles.HexNumber);
return Convert.ToChar(byteValue);
}
}
public DateTime ToDateTime(IFormatProvider provider)
{
throw new InvalidCastException("ByteString to DateTime conversion is not supported.");
}
public decimal ToDecimal(IFormatProvider provider)
{
if (signBit == SignBit.Negative)
{
sbyte byteValue = SByte.Parse(byteString, NumberStyles.HexNumber);
return Convert.ToDecimal(byteValue);
}
else
{
byte byteValue = Byte.Parse(byteString, NumberStyles.HexNumber);
return Convert.ToDecimal(byteValue);
}
}
public double ToDouble(IFormatProvider provider)
{
if (signBit == SignBit.Negative)
return Convert.ToDouble(SByte.Parse(byteString, NumberStyles.HexNumber));
else
return Convert.ToDouble(Byte.Parse(byteString, NumberStyles.HexNumber));
}
public short ToInt16(IFormatProvider provider)
{
if (signBit == SignBit.Negative)
return Convert.ToInt16(SByte.Parse(byteString, NumberStyles.HexNumber));
else
return Convert.ToInt16(Byte.Parse(byteString, NumberStyles.HexNumber));
}
public int ToInt32(IFormatProvider provider)
{
if (signBit == SignBit.Negative)
return Convert.ToInt32(SByte.Parse(byteString, NumberStyles.HexNumber));
else
return Convert.ToInt32(Byte.Parse(byteString, NumberStyles.HexNumber));
}
public long ToInt64(IFormatProvider provider)
{
if (signBit == SignBit.Negative)
return Convert.ToInt64(SByte.Parse(byteString, NumberStyles.HexNumber));
else
return Convert.ToInt64(Byte.Parse(byteString, NumberStyles.HexNumber));
}
public sbyte ToSByte(IFormatProvider provider)
{
try {
return SByte.Parse(byteString, NumberStyles.HexNumber);
}
catch (OverflowException e) {
throw new OverflowException(String.Format("{0} is outside the range of the SByte type.",
Byte.Parse(byteString, NumberStyles.HexNumber)), e);
}
}
public float ToSingle(IFormatProvider provider)
{
if (signBit == SignBit.Negative)
return Convert.ToSingle(SByte.Parse(byteString, NumberStyles.HexNumber));
else
return Convert.ToSingle(Byte.Parse(byteString, NumberStyles.HexNumber));
}
public string ToString(IFormatProvider provider)
{
return "0x" + this.byteString;
}
public object ToType(Type conversionType, IFormatProvider provider)
{
switch (Type.GetTypeCode(conversionType))
{
case TypeCode.Boolean:
return this.ToBoolean(null);
case TypeCode.Byte:
return this.ToByte(null);
case TypeCode.Char:
return this.ToChar(null);
case TypeCode.DateTime:
return this.ToDateTime(null);
case TypeCode.Decimal:
return this.ToDecimal(null);
case TypeCode.Double:
return this.ToDouble(null);
case TypeCode.Int16:
return this.ToInt16(null);
case TypeCode.Int32:
return this.ToInt32(null);
case TypeCode.Int64:
return this.ToInt64(null);
case TypeCode.Object:
if (typeof(ByteString).Equals(conversionType))
return this;
else
throw new InvalidCastException(String.Format("Conversion to a {0} is not supported.", conversionType.Name));
case TypeCode.SByte:
return this.ToSByte(null);
case TypeCode.Single:
return this.ToSingle(null);
case TypeCode.String:
return this.ToString(null);
case TypeCode.UInt16:
return this.ToUInt16(null);
case TypeCode.UInt32:
return this.ToUInt32(null);
case TypeCode.UInt64:
return this.ToUInt64(null);
default:
throw new InvalidCastException(String.Format("Conversion to {0} is not supported.", conversionType.Name));
}
}
public UInt16 ToUInt16(IFormatProvider provider)
{
if (signBit == SignBit.Negative)
throw new OverflowException(String.Format("{0} is outside the range of the UInt16 type.",
SByte.Parse(byteString, NumberStyles.HexNumber)));
else
return Convert.ToUInt16(Byte.Parse(byteString, NumberStyles.HexNumber));
}
public UInt32 ToUInt32(IFormatProvider provider)
{
if (signBit == SignBit.Negative)
throw new OverflowException(String.Format("{0} is outside the range of the UInt32 type.",
SByte.Parse(byteString, NumberStyles.HexNumber)));
else
return Convert.ToUInt32(Byte.Parse(byteString, NumberStyles.HexNumber));
}
public UInt64 ToUInt64(IFormatProvider provider)
{
if (signBit == SignBit.Negative)
throw new OverflowException(String.Format("{0} is outside the range of the UInt64 type.",
SByte.Parse(byteString, NumberStyles.HexNumber)));
else
return Convert.ToUInt64(Byte.Parse(byteString, NumberStyles.HexNumber));
}
}
open System
open System.Globalization
type SignBit =
| Negative = -1
| Zero = 0
| Positive = 1
[<Struct>]
type ByteString =
val mutable private byteString: string
val mutable Sign : SignBit
member this.Value
with get () = this.byteString
and set (value: string) =
if value.Trim().Length > 2 then
invalidArg "value" "The string representation of a byte cannot have more than two characters."
this.byteString <- value
// IConvertible implementations.
interface IConvertible with
member _.GetTypeCode() =
TypeCode.Object
member this.ToBoolean(provider: IFormatProvider) =
this.Sign <> SignBit.Zero
member this.ToByte(provider: IFormatProvider) =
if this.Sign = SignBit.Negative then
raise (OverflowException $"{Convert.ToSByte(this.byteString, 16)} is out of range of the Byte type.")
else
Byte.Parse(this.byteString, NumberStyles.HexNumber)
member this.ToChar(provider: IFormatProvider) =
if this.Sign = SignBit.Negative then
raise (OverflowException $"{Convert.ToSByte(this.byteString, 16)} is out of range of the Char type.")
else
let byteValue = Byte.Parse(this.byteString, NumberStyles.HexNumber)
Convert.ToChar byteValue
member _.ToDateTime(provider: IFormatProvider) =
raise (InvalidCastException "ByteString to DateTime conversion is not supported.")
member this.ToDecimal(provider: IFormatProvider) =
if this.Sign = SignBit.Negative then
SByte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToDecimal
else
Byte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToDecimal
member this.ToDouble(provider: IFormatProvider) =
if this.Sign = SignBit.Negative then
SByte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToDouble
else
Byte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToDouble
member this.ToInt16(provider: IFormatProvider) =
if this.Sign = SignBit.Negative then
SByte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToInt16
else
Byte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToInt16
member this.ToInt32(provider: IFormatProvider) =
if this.Sign = SignBit.Negative then
SByte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToInt32
else
Byte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToInt32
member this.ToInt64(provider: IFormatProvider) =
if this.Sign = SignBit.Negative then
SByte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToInt64
else
Byte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToInt64
member this.ToSByte(provider: IFormatProvider) =
try
SByte.Parse(this.byteString, NumberStyles.HexNumber)
with :? OverflowException as e ->
raise (OverflowException($"{Byte.Parse(this.byteString, NumberStyles.HexNumber)} is outside the range of the SByte type.", e) )
member this.ToSingle(provider: IFormatProvider) =
if this.Sign = SignBit.Negative then
SByte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToSingle
else
Byte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToSingle
member this.ToString(provider: IFormatProvider) =
"0x" + this.byteString
member this.ToType(conversionType: Type, provider: IFormatProvider) =
let this = this :> IConvertible
match Type.GetTypeCode conversionType with
| TypeCode.Boolean ->
this.ToBoolean null
| TypeCode.Byte ->
this.ToByte null
| TypeCode.Char ->
this.ToChar null
| TypeCode.DateTime ->
this.ToDateTime null
| TypeCode.Decimal ->
this.ToDecimal null
| TypeCode.Double ->
this.ToDouble null
| TypeCode.Int16 ->
this.ToInt16 null
| TypeCode.Int32 ->
this.ToInt32 null
| TypeCode.Int64 ->
this.ToInt64 null
| TypeCode.Object ->
if typeof<ByteString>.Equals conversionType then
this
else
raise (InvalidCastException $"Conversion to a {conversionType.Name} is not supported.")
| TypeCode.SByte ->
this.ToSByte null
| TypeCode.Single ->
this.ToSingle null
| TypeCode.String ->
this.ToString null
| TypeCode.UInt16 ->
this.ToUInt16 null
| TypeCode.UInt32 ->
this.ToUInt32 null
| TypeCode.UInt64 ->
this.ToUInt64 null
| _ ->
raise (InvalidCastException $"Conversion to {conversionType.Name} is not supported.")
member this.ToUInt16(provider: IFormatProvider) =
if this.Sign = SignBit.Negative then
raise (OverflowException $"{SByte.Parse(this.byteString, NumberStyles.HexNumber)} is outside the range of the UInt16 type." )
else
Byte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToUInt16
member this.ToUInt32(provider: IFormatProvider) =
if this.Sign = SignBit.Negative then
raise (OverflowException $"{SByte.Parse(this.byteString, NumberStyles.HexNumber)} is outside the range of the UInt32 type.")
else
Byte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToUInt32
member this.ToUInt64(provider: IFormatProvider) =
if this.Sign = SignBit.Negative then
raise (OverflowException $"{SByte.Parse(this.byteString, NumberStyles.HexNumber)} is outside the range of the UInt32 type.")
else
Byte.Parse(this.byteString, NumberStyles.HexNumber)
|> Convert.ToUInt64
Imports System.Globalization
Public Enum SignBit As Integer
Positive = 1
Zero = 0
Negative = -1
End Enum
Public Structure ByteString : Implements IConvertible
Private signBit As SignBit
Private byteString As String
Public Property Sign As SignBit
Set
signBit = value
End Set
Get
Return signBit
End Get
End Property
Public Property Value As String
Set
If value.Trim().Length > 2 Then
Throw New ArgumentException("The string representation of a byte cannot have more than two characters.")
Else
byteString = value
End If
End Set
Get
Return byteString
End Get
End Property
' IConvertible implementations.
Public Function GetTypeCode() As TypeCode _
Implements IConvertible.GetTypeCode
Return TypeCode.Object
End Function
Public Function ToBoolean(provider As IFormatProvider) As Boolean _
Implements IConvertible.ToBoolean
If signBit = SignBit.Zero Then
Return False
Else
Return True
End If
End Function
Public Function ToByte(provider As IFormatProvider) As Byte _
Implements IConvertible.ToByte
If signBit = signBit.Negative Then
Throw New OverflowException(String.Format("{0} is out of range of the Byte type.", Convert.ToSByte(byteString, 16)))
Else
Return Byte.Parse(byteString, NumberStyles.HexNumber)
End If
End Function
Public Function ToChar(provider As IFormatProvider) As Char _
Implements IConvertible.ToChar
If signBit = signBit.Negative Then
Throw New OverflowException(String.Format("{0} is out of range of the Char type.", Convert.ToSByte(byteString, 16)))
Else
Dim byteValue As Byte = Byte.Parse(Me.byteString, NumberStyles.HexNumber)
Return Convert.ToChar(byteValue)
End If
End Function
Public Function ToDateTime(provider As IFormatProvider) As Date _
Implements IConvertible.ToDateTime
Throw New InvalidCastException("ByteString to DateTime conversion is not supported.")
End Function
Public Function ToDecimal(provider As IFormatProvider) As Decimal _
Implements IConvertible.ToDecimal
If signBit = signBit.Negative Then
Dim byteValue As SByte = SByte.Parse(byteString, NumberStyles.HexNumber)
Return Convert.ToDecimal(byteValue)
Else
Dim byteValue As Byte = Byte.Parse(byteString, NumberStyles.HexNumber)
Return Convert.ToDecimal(byteValue)
End If
End Function
Public Function ToDouble(provider As IFormatProvider) As Double _
Implements IConvertible.ToDouble
If signBit = signBit.Negative Then
Return Convert.ToDouble(SByte.Parse(byteString, NumberStyles.HexNumber))
Else
Return Convert.ToDouble(Byte.Parse(byteString, NumberStyles.HexNumber))
End If
End Function
Public Function ToInt16(provider As IFormatProvider) As Int16 _
Implements IConvertible.ToInt16
If signBit = signBit.Negative Then
Return Convert.ToInt16(SByte.Parse(byteString, NumberStyles.HexNumber))
Else
Return Convert.ToInt16(Byte.Parse(byteString, NumberStyles.HexNumber))
End If
End Function
Public Function ToInt32(provider As IFormatProvider) As Int32 _
Implements IConvertible.ToInt32
If signBit = signBit.Negative Then
Return Convert.ToInt32(SByte.Parse(byteString, NumberStyles.HexNumber))
Else
Return Convert.ToInt32(Byte.Parse(byteString, NumberStyles.HexNumber))
End If
End Function
Public Function ToInt64(provider As IFormatProvider) As Int64 _
Implements IConvertible.ToInt64
If signBit = signBit.Negative Then
Return Convert.ToInt64(SByte.Parse(byteString, NumberStyles.HexNumber))
Else
Return Convert.ToInt64(Byte.Parse(byteString, NumberStyles.HexNumber))
End If
End Function
Public Function ToSByte(provider As IFormatProvider) As SByte _
Implements IConvertible.ToSByte
Try
Return SByte.Parse(byteString, NumberStyles.HexNumber)
Catch e As OverflowException
Throw New OverflowException(String.Format("{0} is outside the range of the SByte type.", _
Byte.Parse(byteString, NumberStyles.HexNumber)))
End Try
End Function
Public Function ToSingle(provider As IFormatProvider) As Single _
Implements IConvertible.ToSingle
If signBit = signBit.Negative Then
Return Convert.ToSingle(SByte.Parse(byteString, NumberStyles.HexNumber))
Else
Return Convert.ToSingle(Byte.Parse(byteString, NumberStyles.HexNumber))
End If
End Function
Public Overloads Function ToString(provider As IFormatProvider) As String _
Implements IConvertible.ToString
Return Me.byteString
End Function
Public Function ToType(conversionType As Type, provider As IFormatProvider) As Object _
Implements IConvertible.ToType
Select Case Type.GetTypeCode(conversionType)
Case TypeCode.Boolean
Return Me.ToBoolean(Nothing)
Case TypeCode.Byte
Return Me.ToByte(Nothing)
Case TypeCode.Char
Return Me.ToChar(Nothing)
Case TypeCode.DateTime
Return Me.ToDateTime(Nothing)
Case TypeCode.Decimal
Return Me.ToDecimal(Nothing)
Case TypeCode.Double
Return Me.ToDouble(Nothing)
Case TypeCode.Int16
Return Me.ToInt16(Nothing)
Case TypeCode.Int32
Return Me.ToInt32(Nothing)
Case TypeCode.Int64
Return Me.ToInt64(Nothing)
Case TypeCode.Object
If GetType(ByteString).Equals(conversionType) Then
Return Me
Else
Throw New InvalidCastException(String.Format("Conversion to a {0} is not supported.", conversionType.Name))
End If
Case TypeCode.SByte
Return Me.ToSByte(Nothing)
Case TypeCode.Single
Return Me.ToSingle(Nothing)
Case TypeCode.String
Return Me.ToString(Nothing)
Case TypeCode.UInt16
Return Me.ToUInt16(Nothing)
Case TypeCode.UInt32
Return Me.ToUInt32(Nothing)
Case TypeCode.UInt64
Return Me.ToUInt64(Nothing)
Case Else
Throw New InvalidCastException(String.Format("Conversion to {0} is not supported.", conversionType.Name))
End Select
End Function
Public Function ToUInt16(provider As IFormatProvider) As UInt16 _
Implements IConvertible.ToUInt16
If signBit = signBit.Negative Then
Throw New OverflowException(String.Format("{0} is outside the range of the UInt16 type.", _
SByte.Parse(byteString, NumberStyles.HexNumber)))
Else
Return Convert.ToUInt16(Byte.Parse(byteString, NumberStyles.HexNumber))
End If
End Function
Public Function ToUInt32(provider As IFormatProvider) As UInt32 _
Implements IConvertible.ToUInt32
If signBit = signBit.Negative Then
Throw New OverflowException(String.Format("{0} is outside the range of the UInt32 type.", _
SByte.Parse(byteString, NumberStyles.HexNumber)))
Else
Return Convert.ToUInt32(Byte.Parse(byteString, NumberStyles.HexNumber))
End If
End Function
Public Function ToUInt64(provider As IFormatProvider) As UInt64 _
Implements IConvertible.ToUInt64
If signBit = signBit.Negative Then
Throw New OverflowException(String.Format("{0} is outside the range of the UInt64 type.", _
SByte.Parse(byteString, NumberStyles.HexNumber)))
Else
Return Convert.ToUInt64(Byte.Parse(byteString, NumberStyles.HexNumber))
End If
End Function
End Structure
Nell'esempio seguente viene illustrato come l'implementazione IConvertible.ToSByte della ByteString classe viene chiamata dal Convert.ToSByte(Object, IFormatProvider) metodo .
public class Class1
{
public static void Main()
{
sbyte positiveByte = 120;
sbyte negativeByte = -101;
ByteString positiveString = new ByteString();
positiveString.Sign = (SignBit) Math.Sign(positiveByte);
positiveString.Value = positiveByte.ToString("X2");
ByteString negativeString = new ByteString();
negativeString.Sign = (SignBit) Math.Sign(negativeByte);
negativeString.Value = negativeByte.ToString("X2");
try {
Console.WriteLine("'{0}' converts to {1}.", positiveString.Value, Convert.ToSByte(positiveString));
}
catch (OverflowException) {
Console.WriteLine("0x{0} is outside the range of the Byte type.", positiveString.Value);
}
try {
Console.WriteLine("'{0}' converts to {1}.", negativeString.Value, Convert.ToSByte(negativeString));
}
catch (OverflowException) {
Console.WriteLine("0x{0} is outside the range of the Byte type.", negativeString.Value);
}
}
}
// The example displays the following output:
// '78' converts to 120.
// '9B' converts to -101.
let positiveByte = 120y
let negativeByte = -101y
let mutable positiveString = ByteString()
positiveString.Sign <- sign positiveByte |> enum
positiveString.Value <- positiveByte.ToString "X2"
let mutable negativeString = ByteString()
negativeString.Sign <- sign negativeByte |> enum
negativeString.Value <- negativeByte.ToString "X2"
try
printfn $"'{positiveString.Value}' converts to {Convert.ToSByte positiveString}."
with :? OverflowException ->
printfn $"0x{positiveString.Value} is outside the range of the Byte type."
try
printfn $"'{negativeString.Value}' converts to {Convert.ToSByte negativeString}."
with :? OverflowException ->
printfn $"0x{negativeString.Value} is outside the range of the Byte type."
// The example displays the following output:
// '78' converts to 120.
// '9B' converts to -101.
Module modMain
Public Sub Main()
Dim positiveByte As SByte = 120
Dim negativeByte As SByte = -101
Dim positiveString As New ByteString()
positiveString.Sign = CType(Math.Sign(positiveByte), SignBit)
positiveString.Value = positiveByte.ToString("X2")
Dim negativeString As New ByteString()
negativeString.Sign = CType(Math.Sign(negativeByte), SignBit)
negativeString.Value = negativeByte.ToString("X2")
Try
Console.WriteLine("'{0}' converts to {1}.", positiveString.Value, Convert.ToSByte(positiveString))
Catch e As OverflowException
Console.WriteLine("0x{0} is outside the range of the Byte type.", positiveString.Value)
End Try
Try
Console.WriteLine("'{0}' converts to {1}.", negativeString.Value, Convert.ToSByte(negativeString))
Catch e As OverflowException
Console.WriteLine("0x{0} is outside the range of the Byte type.", negativeString.Value)
End Try
End Sub
End Module
' The example dosplays the following output:
' '78' converts to 120.
' '9B' converts to -101.
Commenti
provider consente all'utente di specificare informazioni sulla conversione specifiche delle impostazioni cultura sul contenuto di value. Ad esempio, se value è un oggetto String che rappresenta un numero, provider potrebbe fornire informazioni specifiche delle impostazioni cultura sulla notazione usata per rappresentare tale numero.
I tipi di base ignorano provider; tuttavia, il parametro può essere usato se value è un tipo definito dall'utente che implementa l'interfaccia IConvertible .
Si applica a
ToSByte(UInt64)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore dell'intero senza segno a 64 bit specificato in un intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(System::UInt64 value);[System.CLSCompliant(false)]
public static sbyte ToSByte (ulong value);[<System.CLSCompliant(false)>]
static member ToSByte : uint64 -> sbytePublic Shared Function ToSByte (value As ULong) As SByteParametri
- value
- UInt64
Intero senza segno a 64 bit da convertire.
Restituisce
Intero con segno a 8 bit equivalente a value.
- Attributi
Eccezioni
value è maggiore di SByte.MaxValue o minore di SByte.MinValue.
Esempio
Nell'esempio seguente viene tentato di convertire ogni elemento in una matrice di interi lunghi in un byte firmato.
ulong[] numbers = { UInt64.MinValue, 121, 340, UInt64.MaxValue };
sbyte result;
foreach (ulong number in numbers)
{
try {
result = Convert.ToSByte(number);
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
number.GetType().Name, number,
result.GetType().Name, result);
}
catch (OverflowException) {
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.",
number.GetType().Name, number);
}
}
// The example displays the following output:
// Converted the UInt64 value 0 to the SByte value 0.
// Converted the UInt64 value 121 to the SByte value 121.
// The UInt64 value 340 is outside the range of the SByte type.
// The UInt64 value 18446744073709551615 is outside the range of the SByte type.
let numbers =
[| UInt32.MinValue; 121u; 340u; UInt32.MaxValue |]
for number in numbers do
try
let result = Convert.ToSByte number
printfn $"Converted the {number.GetType().Name} value {number} to the {result.GetType().Name} value {result}."
with :? OverflowException ->
printfn $"The {number.GetType().Name} value {number} is outside the range of the SByte type."
// The example displays the following output:
// Converted the UInt32 value 0 to the SByte value 0.
// Converted the UInt32 value 121 to the SByte value 121.
// Converted the UInt32 value 340 to the SByte value 340.
// The UInt32 value 4294967295 is outside the range of the SByte type.
Dim numbers() As ULong = { UInt64.MinValue, 121, 340, UInt64.MaxValue }
Dim result As SByte
For Each number As ULong In numbers
Try
result = Convert.ToSByte(number)
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
number.GetType().Name, number, _
result.GetType().Name, result)
Catch e As OverflowException
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.", _
number.GetType().Name, number)
End Try
Next
' The example displays the following output:
' Converted the UInt64 value 0 to the SByte value 0.
' Converted the UInt64 value 121 to the SByte value 121.
' The UInt64 value 340 is outside the range of the SByte type.
' The UInt64 value 18446744073709551615 is outside the range of the SByte type.
Si applica a
ToSByte(UInt32)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore dell'intero senza segno a 32 bit specificato in un intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(System::UInt32 value);[System.CLSCompliant(false)]
public static sbyte ToSByte (uint value);[<System.CLSCompliant(false)>]
static member ToSByte : uint32 -> sbytePublic Shared Function ToSByte (value As UInteger) As SByteParametri
- value
- UInt32
Intero senza segno a 32 bit da convertire.
Restituisce
Intero con segno a 8 bit equivalente a value.
- Attributi
Eccezioni
value è maggiore di SByte.MaxValue o minore di SByte.MinValue.
Esempio
Nell'esempio seguente viene eseguito un tentativo di convertire ogni elemento in una matrice integer in un byte con segno.
uint[] numbers = { UInt32.MinValue, 121, 340, UInt32.MaxValue };
sbyte result;
foreach (uint number in numbers)
{
try {
result = Convert.ToSByte(number);
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
number.GetType().Name, number,
result.GetType().Name, result);
}
catch (OverflowException) {
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.",
number.GetType().Name, number);
}
}
// The example displays the following output:
// Converted the UInt32 value 0 to the SByte value 0.
// Converted the UInt32 value 121 to the SByte value 121.
// The UInt32 value 340 is outside the range of the SByte type.
// The UInt32 value 4294967295 is outside the range of the SByte type.
let numbers =
[| UInt16.MinValue; 121us; 340us; UInt16.MaxValue |]
for number in numbers do
try
let result = Convert.ToSByte number
printfn $"Converted the {number.GetType().Name} value {number} to the {result.GetType().Name} value {result}."
with :? OverflowException ->
printfn $"The {number.GetType().Name} value {number} is outside the range of the SByte type."
// The example displays the following output:
// Converted the UInt16 value 0 to the SByte value 0.
// Converted the UInt16 value 121 to the SByte value 121.
// Converted the UInt16 value 340 to the SByte value 340.
// Converted the UInt16 value 65535 to the SByte value 65535.
Dim numbers() As UInteger = { UInt32.MinValue, 121, 340, UInt32.MaxValue }
Dim result As SByte
For Each number As UInteger In numbers
Try
result = Convert.ToSByte(number)
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
number.GetType().Name, number, _
result.GetType().Name, result)
Catch e As OverflowException
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.", _
number.GetType().Name, number)
End Try
Next
' The example displays the following output:
' Converted the UInt32 value 0 to the SByte value 0.
' Converted the UInt32 value 121 to the SByte value 121.
' The UInt32 value 340 is outside the range of the SByte type.
' The UInt32 value 4294967295 is outside the range of the SByte type.
Si applica a
ToSByte(String)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte la rappresentazione di stringa specificata di un numero in un intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(System::String ^ value);[System.CLSCompliant(false)]
public static sbyte ToSByte (string value);[System.CLSCompliant(false)]
public static sbyte ToSByte (string? value);[<System.CLSCompliant(false)>]
static member ToSByte : string -> sbytePublic Shared Function ToSByte (value As String) As SByteParametri
- value
- String
Stringa che contiene il numero da convertire.
Restituisce
Intero con segno a 8 bit equivalente al numero in value oppure 0 (zero) se value è null.
- Attributi
Eccezioni
value non è costituito da un segno facoltativo seguito da una sequenza di cifre (da 0 a 9).
value rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue.
Esempio
Nell'esempio seguente le rappresentazioni di stringa dei SByte valori con il metodo utilizzano la ToSByte formattazione predefinita.
// Example of the Convert::ToSByte( String* ) and
// Convert::ToSByte( String*, IFormatProvider* ) methods.
using namespace System;
using namespace System::Globalization;
const __wchar_t * protoFmt = L"{0,-20}{1,-20}{2}";
// Get the exception type name; remove the namespace prefix.
String^ GetExceptionType( Exception^ ex )
{
String^ exceptionType = ex->GetType()->ToString();
return exceptionType->Substring( exceptionType->LastIndexOf( '.' ) + 1 );
}
void ConvertToSByte( String^ numericStr, IFormatProvider^ provider )
{
Object^ defaultValue;
Object^ providerValue;
// Convert numericStr to SByte without a format provider.
try
{
defaultValue = Convert::ToSByte( numericStr );
}
catch ( Exception^ ex )
{
defaultValue = GetExceptionType( ex );
}
// Convert numericStr to SByte with a format provider.
try
{
providerValue = Convert::ToSByte( numericStr, provider );
}
catch ( Exception^ ex )
{
providerValue = GetExceptionType( ex );
}
Console::WriteLine( gcnew String( protoFmt ), numericStr, defaultValue, providerValue );
}
int main()
{
// Create a NumberFormatInfo object and set several of its
// properties that apply to numbers.
NumberFormatInfo^ provider = gcnew NumberFormatInfo;
// These properties affect the conversion.
provider->NegativeSign = "neg ";
provider->PositiveSign = "pos ";
// These properties do not affect the conversion.
// The input string cannot have decimal and group separators.
provider->NumberDecimalSeparator = ".";
provider->NumberNegativePattern = 0;
Console::WriteLine( "This example of\n"
" Convert::ToSByte( String* ) and \n"
" Convert::ToSByte( String*, IFormatProvider* ) "
"\ngenerates the following output. It converts "
"several strings to \nSByte values, using "
"default formatting or a NumberFormatInfo object.\n" );
Console::WriteLine( gcnew String( protoFmt ), "String to convert", "Default/exception", "Provider/exception" );
Console::WriteLine( gcnew String( protoFmt ), "-----------------", "-----------------", "------------------" );
// Convert strings, with and without an IFormatProvider.
ConvertToSByte( "123", provider );
ConvertToSByte( "+123", provider );
ConvertToSByte( "pos 123", provider );
ConvertToSByte( "-123", provider );
ConvertToSByte( "neg 123", provider );
ConvertToSByte( "123.", provider );
ConvertToSByte( "(123)", provider );
ConvertToSByte( "128", provider );
ConvertToSByte( "-129", provider );
}
/*
This example of
Convert::ToSByte( String* ) and
Convert::ToSByte( String*, IFormatProvider* )
generates the following output. It converts several strings to
SByte values, using default formatting or a NumberFormatInfo object.
String to convert Default/exception Provider/exception
----------------- ----------------- ------------------
123 123 123
+123 123 FormatException
pos 123 FormatException 123
-123 -123 FormatException
neg 123 FormatException -123
123. FormatException FormatException
(123) FormatException FormatException
128 OverflowException OverflowException
-129 OverflowException FormatException
*/
// Example of the Convert.ToSByte( string ) and
// Convert.ToSByte( string, IFormatProvider ) methods.
using System;
using System.Globalization;
class ToSByteProviderDemo
{
static string format = "{0,-20}{1,-20}{2}";
// Get the exception type name; remove the namespace prefix.
static string GetExceptionType( Exception ex )
{
string exceptionType = ex.GetType( ).ToString( );
return exceptionType.Substring(
exceptionType.LastIndexOf( '.' ) + 1 );
}
static void ConvertToSByte( string numericStr,
IFormatProvider provider )
{
object defaultValue;
object providerValue;
// Convert numericStr to SByte without a format provider.
try
{
defaultValue = Convert.ToSByte( numericStr );
}
catch( Exception ex )
{
defaultValue = GetExceptionType( ex );
}
// Convert numericStr to SByte with a format provider.
try
{
providerValue = Convert.ToSByte( numericStr, provider );
}
catch( Exception ex )
{
providerValue = GetExceptionType( ex );
}
Console.WriteLine( format, numericStr,
defaultValue, providerValue );
}
public static void Main( )
{
// Create a NumberFormatInfo object and set several of its
// properties that apply to numbers.
NumberFormatInfo provider = new NumberFormatInfo();
// These properties affect the conversion.
provider.NegativeSign = "neg ";
provider.PositiveSign = "pos ";
// These properties do not affect the conversion.
// The input string cannot have decimal and group separators.
provider.NumberDecimalSeparator = ".";
provider.NumberNegativePattern = 0;
Console.WriteLine("This example of\n" +
" Convert.ToSByte( string ) and \n" +
" Convert.ToSByte( string, IFormatProvider ) " +
"\ngenerates the following output. It converts " +
"several strings to \nSByte values, using " +
"default formatting or a NumberFormatInfo object.\n" );
Console.WriteLine( format, "String to convert",
"Default/exception", "Provider/exception" );
Console.WriteLine( format, "-----------------",
"-----------------", "------------------" );
// Convert strings, with and without an IFormatProvider.
ConvertToSByte( "123", provider );
ConvertToSByte( "+123", provider );
ConvertToSByte( "pos 123", provider );
ConvertToSByte( "-123", provider );
ConvertToSByte( "neg 123", provider );
ConvertToSByte( "123.", provider );
ConvertToSByte( "(123)", provider );
ConvertToSByte( "128", provider );
ConvertToSByte( "-129", provider );
}
}
/*
This example of
Convert.ToSByte( string ) and
Convert.ToSByte( string, IFormatProvider )
generates the following output. It converts several strings to
SByte values, using default formatting or a NumberFormatInfo object.
String to convert Default/exception Provider/exception
----------------- ----------------- ------------------
123 123 123
+123 123 FormatException
pos 123 FormatException 123
-123 -123 FormatException
neg 123 FormatException -123
123. FormatException FormatException
(123) FormatException FormatException
128 OverflowException OverflowException
-129 OverflowException FormatException
*/
// Example of the Convert.ToSByte( string ) and
// Convert.ToSByte( string, IFormatProvider ) methods.
open System
open System.Globalization
let format obj1 obj2 obj3 = printfn $"{obj1,-20}{obj2,-20}{obj3}"
// Get the exception type name; remove the namespace prefix.
let getExceptionType (ex: exn) =
let exceptionType = ex.GetType() |> string
exceptionType.Substring(exceptionType.LastIndexOf '.' + 1 )
let convertToSByte (numericStr: string) (provider: IFormatProvider) =
// Convert numericStr to SByte without a format provider.
let defaultValue =
try
Convert.ToSByte numericStr
|> string
with ex ->
getExceptionType ex
// Convert numericStr to SByte with a format provider.
let providerValue =
try
Convert.ToSByte(numericStr, provider)
|> string
with ex ->
getExceptionType ex
format numericStr defaultValue providerValue
// Create a NumberFormatInfo object and set several of its
// properties that apply to numbers.
let provider = NumberFormatInfo()
// These properties affect the conversion.
provider.NegativeSign <- "neg "
provider.PositiveSign <- "pos "
// These properties do not affect the conversion.
// The input string cannot have decimal and group separators.
provider.NumberDecimalSeparator <- "."
provider.NumberNegativePattern <- 0
printfn
"""This example of
Convert.ToSByte( string ) and
Convert.ToSByte( string, IFormatProvider )
generates the following output. It converts several strings to
SByte values, using default formatting or a NumberFormatInfo object.
"""
format "String to convert" "Default/exception" "Provider/exception"
format "-----------------" "-----------------" "------------------"
// Convert strings, with and without an IFormatProvider.
convertToSByte "123" provider
convertToSByte "+123" provider
convertToSByte "pos 123" provider
convertToSByte "-123" provider
convertToSByte "neg 123" provider
convertToSByte "123." provider
convertToSByte "(123)" provider
convertToSByte "128" provider
convertToSByte "-129" provider
// This example of
// Convert.ToSByte( string ) and
// Convert.ToSByte( string, IFormatProvider )
// generates the following output. It converts several strings to
// SByte values, using default formatting or a NumberFormatInfo object.
// String to convert Default/exception Provider/exception
// ----------------- ----------------- ------------------
// 123 123 123
// +123 123 FormatException
// pos 123 FormatException 123
// -123 -123 FormatException
// neg 123 FormatException -123
// 123. FormatException FormatException
// (123) FormatException FormatException
// 128 OverflowException OverflowException
// -129 OverflowException FormatException
' Example of the Convert.ToSByte( String ) and
' Convert.ToSByte( String, IFormatProvider ) methods.
Imports System.Globalization
Module ToSByteProviderDemo
Dim format As String = "{0,-20}{1,-20}{2}"
' Get the exception type name; remove the namespace prefix.
Function GetExceptionType( ex As Exception ) As String
Dim exceptionType As String = ex.GetType( ).ToString( )
Return exceptionType.Substring( _
exceptionType.LastIndexOf( "."c ) + 1 )
End Function
Sub ConvertToSByte( numericStr As String, _
provider As IFormatProvider )
Dim defaultValue As Object
Dim providerValue As Object
' Convert numericStr to SByte without a format provider.
Try
defaultValue = Convert.ToSByte( numericStr )
Catch ex As Exception
defaultValue = GetExceptionType( ex )
End Try
' Convert numericStr to SByte with a format provider.
Try
providerValue = Convert.ToSByte( numericStr, provider )
Catch ex As Exception
providerValue = GetExceptionType( ex )
End Try
Console.WriteLine( format, numericStr, _
defaultValue, providerValue )
End Sub
Sub Main( )
' Create a NumberFormatInfo object and set several of its
' properties that apply to numbers.
Dim provider As NumberFormatInfo = new NumberFormatInfo( )
' These properties affect the conversion.
provider.NegativeSign = "neg "
provider.PositiveSign = "pos "
' These properties do not affect the conversion.
' The input string cannot have decimal and group separators.
provider.NumberDecimalSeparator = "."
provider.NumberNegativePattern = 0
Console.WriteLine( "This example of" & vbCrLf & _
" Convert.ToSByte( String ) and " & vbCrLf & _
" Convert.ToSByte( String, IFormatProvider ) " & _
vbCrLf & "generates the following output. It " & _
"converts several strings to " & vbCrLf & "SByte " & _
"values, using default formatting " & _
"or a NumberFormatInfo object." & vbCrLf )
Console.WriteLine( format, "String to convert", _
"Default/exception", "Provider/exception" )
Console.WriteLine( format, "-----------------", _
"-----------------", "------------------" )
' Convert strings, with and without an IFormatProvider.
ConvertToSByte( "123", provider )
ConvertToSByte( "+123", provider )
ConvertToSByte( "pos 123", provider )
ConvertToSByte( "-123", provider )
ConvertToSByte( "neg 123", provider )
ConvertToSByte( "123.", provider )
ConvertToSByte( "(123)", provider )
ConvertToSByte( "128", provider )
ConvertToSByte( "-129", provider )
End Sub
End Module
' This example of
' Convert.ToSByte( String ) and
' Convert.ToSByte( String, IFormatProvider )
' generates the following output. It converts several strings to
' SByte values, using default formatting or a NumberFormatInfo object.
'
' String to convert Default/exception Provider/exception
' ----------------- ----------------- ------------------
' 123 123 123
' +123 123 FormatException
' pos 123 FormatException 123
' -123 -123 FormatException
' neg 123 FormatException -123
' 123. FormatException FormatException
' (123) FormatException FormatException
' 128 OverflowException OverflowException
' -129 OverflowException FormatException
Commenti
L'uso del ToSByte(String) metodo equivale al passaggio value al SByte.Parse(String) metodo . value viene interpretato usando le convenzioni di formattazione delle impostazioni cultura correnti.
Se si preferisce non gestire un'eccezione se la conversione non riesce, è invece possibile chiamare il SByte.TryParse metodo . Restituisce un Boolean valore che indica se la conversione ha avuto esito positivo o negativo.
Vedi anche
Si applica a
ToSByte(Single)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore del numero a virgola mobile e con precisione singola specificato in un intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(float value);[System.CLSCompliant(false)]
public static sbyte ToSByte (float value);[<System.CLSCompliant(false)>]
static member ToSByte : single -> sbytePublic Shared Function ToSByte (value As Single) As SByteParametri
- value
- Single
Numero a virgola mobile a precisione singola da convertire.
Restituisce
value, arrotondato all'intero con segno a 8 bit più vicino. Se value si trova a metà tra due numeri interi, viene restituito il numero intero pari; vale a dire, 4,5 viene convertito in 4, mentre 5,5 viene convertito in 6.
- Attributi
Eccezioni
value è maggiore di SByte.MaxValue o minore di SByte.MinValue.
Esempio
L'esempio seguente tenta di convertire ogni elemento in una matrice di Single valori in un byte firmato.
object[] values = { true, -12, 163, 935, 'x', "104", "103.0", "-1",
"1.00e2", "One", 1.00e2};
sbyte result;
foreach (object value in values)
{
try {
result = Convert.ToSByte(value);
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
value.GetType().Name, value,
result.GetType().Name, result);
}
catch (OverflowException) {
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.",
value.GetType().Name, value);
}
catch (FormatException) {
Console.WriteLine("The {0} value {1} is not in a recognizable format.",
value.GetType().Name, value);
}
catch (InvalidCastException) {
Console.WriteLine("No conversion to a Byte exists for the {0} value {1}.",
value.GetType().Name, value);
}
}
// The example displays the following output:
// Converted the Boolean value true to the SByte value 1.
// Converted the Int32 value -12 to the SByte value -12.
// The Int32 value 163 is outside the range of the SByte type.
// The Int32 value 935 is outside the range of the SByte type.
// Converted the Char value x to the SByte value 120.
// Converted the String value 104 to the SByte value 104.
// The String value 103.0 is not in a recognizable format.
// Converted the String value -1 to the SByte value -1.
// The String value 1.00e2 is not in a recognizable format.
// The String value One is not in a recognizable format.
// Converted the Double value 100 to the SByte value 100.
let values: obj[] =
[| true; -12; 163; 935; 'x'; DateTime(2009, 5, 12)
"104"; "103.0"; "-1"
"1.00e2"; "One"; 1.00e2; 16.3e42 |]
for value in values do
try
let result = Convert.ToSByte value
printfn $"Converted the {value.GetType().Name} value {value} to the {result.GetType().Name} value {result}."
with
| :? OverflowException ->
printfn $"The {value.GetType().Name} value {value} is outside the range of the SByte type."
| :? FormatException ->
printfn $"The {value.GetType().Name} value {value} is not in a recognizable format."
| :? InvalidCastException ->
printfn $"No conversion to an SByte exists for the {value.GetType().Name} value {value}."
// The example displays the following output:
// Converted the Boolean value True to the SByte value 1.
// Converted the Int32 value -12 to the SByte value -12.
// Converted the Int32 value 163 to the SByte value 163.
// Converted the Int32 value 935 to the SByte value 935.
// Converted the Char value x to the SByte value 120.
// No conversion to an SByte exists for the DateTime value 5/12/2009 12:00:00 AM.
// Converted the String value 104 to the SByte value 104.
// The String value 103.0 is not in a recognizable format.
// Converted the String value -1 to the SByte value -1.
// The String value 1.00e2 is not in a recognizable format.
// The String value One is not in a recognizable format.
// Converted the Double value 100 to the SByte value 100.
// The Double value 1.63E+43 is outside the range of the SByte type.
Dim values() As Object = { True, -12, 163, 935, "x"c, "104", "103.0", "-1", _
"1.00e2", "One", 1.00e2}
Dim result As SByte
For Each value As Object In values
Try
result = Convert.ToSByte(value)
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
value.GetType().Name, value, _
result.GetType().Name, result)
Catch e As OverflowException
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.", _
value.GetType().Name, value)
Catch e As FormatException
Console.WriteLine("The {0} value {1} is not in a recognizable format.", _
value.GetType().Name, value)
Catch e As InvalidCastException
Console.WriteLine("No conversion to a Byte exists for the {0} value {1}.", _
value.GetType().Name, value)
End Try
Next
' The example displays the following output:
' Converted the Boolean value True to the SByte value 1.
' Converted the Int32 value -12 to the SByte value -12.
' The Int32 value 163 is outside the range of the SByte type.
' The Int32 value 935 is outside the range of the SByte type.
' Converted the Char value x to the SByte value 120.
' Converted the String value 104 to the SByte value 104.
' The String value 103.0 is not in a recognizable format.
' Converted the String value -1 to the SByte value -1.
' The String value 1.00e2 is not in a recognizable format.
' The String value One is not in a recognizable format.
' Converted the Double value 100 to the SByte value 100.
Vedi anche
Si applica a
ToSByte(Object)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore dell'oggetto specificato in un intero con segno a 8 bit.
public:
static System::SByte ToSByte(System::Object ^ value);[System.CLSCompliant(false)]
public static sbyte ToSByte (object value);[System.CLSCompliant(false)]
public static sbyte ToSByte (object? value);[<System.CLSCompliant(false)>]
static member ToSByte : obj -> sbytePublic Shared Function ToSByte (value As Object) As SByteParametri
- value
- Object
Oggetto che implementa l'interfaccia IConvertible oppure null.
Restituisce
Intero con segno a 8 bit equivalente a value oppure zero se value è null.
- Attributi
Eccezioni
Il formato di value non è appropriato.
value rappresenta un numero minore di SByte.MinValue o maggiore di SByte.MaxValue.
Esempio
Nell'esempio seguente viene eseguito un tentativo di convertire ogni elemento in una matrice di oggetti in un byte firmato.
object[] values = { true, -12, 163, 935, 'x', "104", "103.0", "-1",
"1.00e2", "One", 1.00e2};
sbyte result;
foreach (object value in values)
{
try {
result = Convert.ToSByte(value);
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
value.GetType().Name, value,
result.GetType().Name, result);
}
catch (OverflowException) {
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.",
value.GetType().Name, value);
}
catch (FormatException) {
Console.WriteLine("The {0} value {1} is not in a recognizable format.",
value.GetType().Name, value);
}
catch (InvalidCastException) {
Console.WriteLine("No conversion to a Byte exists for the {0} value {1}.",
value.GetType().Name, value);
}
}
// The example displays the following output:
// Converted the Boolean value true to the SByte value 1.
// Converted the Int32 value -12 to the SByte value -12.
// The Int32 value 163 is outside the range of the SByte type.
// The Int32 value 935 is outside the range of the SByte type.
// Converted the Char value x to the SByte value 120.
// Converted the String value 104 to the SByte value 104.
// The String value 103.0 is not in a recognizable format.
// Converted the String value -1 to the SByte value -1.
// The String value 1.00e2 is not in a recognizable format.
// The String value One is not in a recognizable format.
// Converted the Double value 100 to the SByte value 100.
let values: obj[] =
[| true; -12; 163; 935; 'x'; DateTime(2009, 5, 12)
"104"; "103.0"; "-1"
"1.00e2"; "One"; 1.00e2; 16.3e42 |]
for value in values do
try
let result = Convert.ToSByte value
printfn $"Converted the {value.GetType().Name} value {value} to the {result.GetType().Name} value {result}."
with
| :? OverflowException ->
printfn $"The {value.GetType().Name} value {value} is outside the range of the SByte type."
| :? FormatException ->
printfn $"The {value.GetType().Name} value {value} is not in a recognizable format."
| :? InvalidCastException ->
printfn $"No conversion to an SByte exists for the {value.GetType().Name} value {value}."
// The example displays the following output:
// Converted the Boolean value True to the SByte value 1.
// Converted the Int32 value -12 to the SByte value -12.
// Converted the Int32 value 163 to the SByte value 163.
// Converted the Int32 value 935 to the SByte value 935.
// Converted the Char value x to the SByte value 120.
// No conversion to an SByte exists for the DateTime value 5/12/2009 12:00:00 AM.
// Converted the String value 104 to the SByte value 104.
// The String value 103.0 is not in a recognizable format.
// Converted the String value -1 to the SByte value -1.
// The String value 1.00e2 is not in a recognizable format.
// The String value One is not in a recognizable format.
// Converted the Double value 100 to the SByte value 100.
// The Double value 1.63E+43 is outside the range of the SByte type.
Dim values() As Object = { True, -12, 163, 935, "x"c, "104", "103.0", "-1", _
"1.00e2", "One", 1.00e2}
Dim result As SByte
For Each value As Object In values
Try
result = Convert.ToSByte(value)
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
value.GetType().Name, value, _
result.GetType().Name, result)
Catch e As OverflowException
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.", _
value.GetType().Name, value)
Catch e As FormatException
Console.WriteLine("The {0} value {1} is not in a recognizable format.", _
value.GetType().Name, value)
Catch e As InvalidCastException
Console.WriteLine("No conversion to a Byte exists for the {0} value {1}.", _
value.GetType().Name, value)
End Try
Next
' The example displays the following output:
' Converted the Boolean value True to the SByte value 1.
' Converted the Int32 value -12 to the SByte value -12.
' The Int32 value 163 is outside the range of the SByte type.
' The Int32 value 935 is outside the range of the SByte type.
' Converted the Char value x to the SByte value 120.
' Converted the String value 104 to the SByte value 104.
' The String value 103.0 is not in a recognizable format.
' Converted the String value -1 to the SByte value -1.
' The String value 1.00e2 is not in a recognizable format.
' The String value One is not in a recognizable format.
' Converted the Double value 100 to the SByte value 100.
Commenti
Il valore restituito è il risultato di richiamare il IConvertible.ToSByte metodo del tipo sottostante di value.
Si applica a
ToSByte(UInt16)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore dell'intero senza segno a 16 bit specificato nell'intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(System::UInt16 value);[System.CLSCompliant(false)]
public static sbyte ToSByte (ushort value);[<System.CLSCompliant(false)>]
static member ToSByte : uint16 -> sbytePublic Shared Function ToSByte (value As UShort) As SByteParametri
- value
- UInt16
Intero senza segno a 16 bit da convertire.
Restituisce
Intero con segno a 8 bit equivalente a value.
- Attributi
Eccezioni
value è maggiore di SByte.MaxValue.
Esempio
L'esempio seguente tenta di convertire ogni elemento in una matrice di interi senza segno a 16 bit in un byte con segno.
ushort[] numbers = { UInt16.MinValue, 121, 340, UInt16.MaxValue };
sbyte result;
foreach (ushort number in numbers)
{
try {
result = Convert.ToSByte(number);
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
number.GetType().Name, number,
result.GetType().Name, result);
}
catch (OverflowException) {
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.",
number.GetType().Name, number);
}
}
// The example displays the following output:
// Converted the UInt16 value 0 to the SByte value 0.
// Converted the UInt16 value 121 to the SByte value 121.
// The UInt16 value 340 is outside the range of the SByte type.
// The UInt16 value 65535 is outside the range of the SByte type.
let values =
[| "One"; "1.34e28"; "-26.87"; "-18"; "-6.00"
" 0"; "137"; "1601.9"; string Int32.MaxValue |]
for value in values do
try
let result = Convert.ToSByte value
printfn $"Converted the {value.GetType().Name} value {value} to the {result.GetType().Name} value {result}."
with
| :? OverflowException ->
printfn $"{value} is outside the range of the SByte type."
| :? FormatException ->
printfn $"The {value.GetType().Name} value '{value}' is not in a recognizable format."
// The example displays the following output:
// The String value 'One' is not in a recognizable format.
// The String value '1.34e28' is not in a recognizable format.
// The String value '-26.87' is not in a recognizable format.
// Converted the String value '-18' to the SByte value -18.
// The String value '-6.00' is not in a recognizable format.
// Converted the String value ' 0' to the SByte value 0.
// Converted the String value '137' to the SByte value 137.
// The String value '1601.9' is not in a recognizable format.
// Converted the String value '2147483647' to the SByte value 2147483647.
Dim numbers() As UShort = { UInt16.MinValue, 121, 340, UInt16.MaxValue }
Dim result As SByte
For Each number As UShort In numbers
Try
result = Convert.ToSByte(number)
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
number.GetType().Name, number, _
result.GetType().Name, result)
Catch e As OverflowException
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.", _
number.GetType().Name, number)
End Try
Next
' The example displays the following output:
' Converted the UInt16 value 0 to the SByte value 0.
' Converted the UInt16 value 121 to the SByte value 121.
' The UInt16 value 340 is outside the range of the SByte type.
' The UInt16 value 65535 is outside the range of the SByte type.
Si applica a
ToSByte(Int32)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore dell'intero con segno a 32 bit specificato in un intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(int value);[System.CLSCompliant(false)]
public static sbyte ToSByte (int value);[<System.CLSCompliant(false)>]
static member ToSByte : int -> sbytePublic Shared Function ToSByte (value As Integer) As SByteParametri
- value
- Int32
Intero con segno a 32 bit da convertire.
Restituisce
Intero con segno a 8 bit equivalente a value.
- Attributi
Eccezioni
value è maggiore di SByte.MaxValue o minore di SByte.MinValue.
Esempio
Nell'esempio seguente viene eseguito un tentativo di convertire ogni elemento in una matrice di interi con segno in un byte con segno.
int[] numbers = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue };
sbyte result;
foreach (int number in numbers)
{
try {
result = Convert.ToSByte(number);
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
number.GetType().Name, number,
result.GetType().Name, result);
}
catch (OverflowException) {
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.",
number.GetType().Name, number);
}
}
// The example displays the following output:
// The Int32 value -2147483648 is outside the range of the SByte type.
// Converted the Int32 value -1 to the SByte value -1.
// Converted the Int32 value 0 to the SByte value 0.
// Converted the Int32 value 121 to the SByte value 121.
// The Int32 value 340 is outside the range of the SByte type.
// The Int32 value 2147483647 is outside the range of the SByte type.
let numbers =
[| Int32.MinValue; -1; 0; 121; 340; Int32.MaxValue |]
for number in numbers do
try
let result = Convert.ToSByte number
printfn $"Converted the {number.GetType().Name} value {number} to the {result.GetType().Name} value {result}."
with :? OverflowException ->
printfn $"The {number.GetType().Name} value {number} is outside the range of the SByte type."
// The example displays the following output:
// The Int32 value -2147483647 is outside the range of the SByte type.
// Converted the Int32 value -1 to the SByte value -1.
// Converted the Int32 value 0 to the SByte value 0.
// Converted the Int32 value 121 to the SByte value 121.
// Converted the Int32 value 340 to the SByte value 340.
// The Int32 value 2147483647 is outside the range of the SByte type.
Dim numbers() As Integer = { Int32.MinValue, -1, 0, 121, 340, Int32.MaxValue }
Dim result As SByte
For Each number As Integer In numbers
Try
result = Convert.ToSByte(number)
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
number.GetType().Name, number, _
result.GetType().Name, result)
Catch e As OverflowException
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.", _
number.GetType().Name, number)
End Try
Next
' The example displays the following output:
' The Int32 value -2147483648 is outside the range of the SByte type.
' Converted the Int32 value -1 to the SByte value -1.
' Converted the Int32 value 0 to the SByte value 0.
' Converted the Int32 value 121 to the SByte value 121.
' The Int32 value 340 is outside the range of the SByte type.
' The Int32 value 2147483647 is outside the range of the SByte type.
Si applica a
ToSByte(Int64)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore dell'intero con segno a 64 bit specificato in un intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(long value);[System.CLSCompliant(false)]
public static sbyte ToSByte (long value);[<System.CLSCompliant(false)>]
static member ToSByte : int64 -> sbytePublic Shared Function ToSByte (value As Long) As SByteParametri
- value
- Int64
Intero con segno a 64 bit da convertire.
Restituisce
Intero con segno a 8 bit equivalente a value.
- Attributi
Eccezioni
value è maggiore di SByte.MaxValue o minore di SByte.MinValue.
Esempio
Nell'esempio seguente viene eseguito un tentativo di convertire ogni elemento in una matrice di numeri interi lunghi in un byte con segno.
long[] numbers = { Int64.MinValue, -1, 0, 121, 340, Int64.MaxValue };
sbyte result;
foreach (long number in numbers)
{
try {
result = Convert.ToSByte(number);
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
number.GetType().Name, number,
result.GetType().Name, result);
}
catch (OverflowException) {
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.",
number.GetType().Name, number);
}
}
// The example displays the following output:
// The Int64 value -9223372036854775808 is outside the range of the SByte type.
// Converted the Int64 value -1 to the SByte value -1.
// Converted the Int64 value 0 to the SByte value 0.
// Converted the Int64 value 121 to the SByte value 121.
// The Int64 value 340 is outside the range of the SByte type.
// The Int64 value 9223372036854775807 is outside the range of the SByte type.
let numbers =
[| Int64.MinValue; -1L; 0L; 121L; 340L; Int64.MaxValue |]
for number in numbers do
try
let result = Convert.ToSByte number
printfn $"Converted the {number.GetType().Name} value {number} to the {result.GetType().Name} value {result}."
with :? OverflowException ->
printfn $"The {number.GetType().Name} value {number} is outside the range of the SByte type."
// The example displays the following output:
// The Int64 value -9223372036854775808 is outside the range of the SByte type.
// Converted the Int64 value -1 to the SByte value -1.
// Converted the Int64 value 0 to the SByte value 0.
// Converted the Int64 value 121 to the SByte value 121.
// Converted the Int64 value 340 to the SByte value 340.
// The Int64 value 9223372036854775807 is outside the range of the SByte type.
Dim numbers() As Long = { Int64.MinValue, -1, 0, 121, 340, Int64.MaxValue }
Dim result As SByte
For Each number As Long In numbers
Try
result = Convert.ToSByte(number)
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
number.GetType().Name, number, _
result.GetType().Name, result)
Catch e As OverflowException
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.", _
number.GetType().Name, number)
End Try
Next
' The example displays the following output:
' The Int64 value -9223372036854775808 is outside the range of the SByte type.
' Converted the Int64 value -1 to the SByte value -1.
' Converted the Int64 value 0 to the SByte value 0.
' Converted the Int64 value 121 to the SByte value 121.
' The Int64 value 340 is outside the range of the SByte type.
' The Int64 value 9223372036854775807 is outside the range of the SByte type.
Si applica a
ToSByte(Byte)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore dell'intero senza segno a 8 bit specificato nell'intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(System::Byte value);[System.CLSCompliant(false)]
public static sbyte ToSByte (byte value);[<System.CLSCompliant(false)>]
static member ToSByte : byte -> sbytePublic Shared Function ToSByte (value As Byte) As SByteParametri
- value
- Byte
Intero senza segno a 8 bit da convertire.
Restituisce
Intero con segno a 8 bit equivalente a value.
- Attributi
Eccezioni
value è maggiore di SByte.MaxValue.
Esempio
L'esempio seguente tenta di convertire ogni elemento in una matrice di byte in un byte firmato.
byte[] numbers = { Byte.MinValue, 10, 100, Byte.MaxValue };
sbyte result;
foreach (byte number in numbers)
{
try {
result = Convert.ToSByte(number);
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
number.GetType().Name, number,
result.GetType().Name, result);
}
catch (OverflowException) {
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.",
number.GetType().Name, number);
}
}
// The example displays the following output:
// Converted the Byte value 0 to the SByte value 0.
// Converted the Byte value 10 to the SByte value 10.
// Converted the Byte value 100 to the SByte value 100.
// The Byte value 255 is outside the range of the SByte type.
let bytes =
[| Byte.MinValue; 14uy; 122uy; Byte.MaxValue |]
for byteValue in bytes do
let result = Convert.ToSByte byteValue
printfn $"Converted the {byteValue.GetType().Name} value {byteValue} to the {result.GetType().Name} value {result}."
// The example displays the following output:
// Converted the Byte value 0 to the SByte value 0.
// Converted the Byte value 14 to the SByte value 14.
// Converted the Byte value 122 to the SByte value 122.
// Converted the Byte value 255 to the SByte value 255.
Dim numbers() As Byte = { Byte.MinValue, 10, 100, Byte.MaxValue }
Dim result As SByte
For Each number As Byte In numbers
Try
result = Convert.ToSByte(number)
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
number.GetType().Name, number, _
result.GetType().Name, result)
Catch e As OverflowException
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.", _
number.GetType().Name, number)
End Try
Next
' The example displays the following output:
' Converted the Byte value 0 to the SByte value 0.
' Converted the Byte value 10 to the SByte value 10.
' Converted the Byte value 100 to the SByte value 100.
' The Byte value 255 is outside the range of the SByte type.
Si applica a
ToSByte(Char)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore del carattere Unicode specificato nell'intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(char value);[System.CLSCompliant(false)]
public static sbyte ToSByte (char value);[<System.CLSCompliant(false)>]
static member ToSByte : char -> sbytePublic Shared Function ToSByte (value As Char) As SByteParametri
- value
- Char
Carattere Unicode da convertire.
Restituisce
Intero con segno a 8 bit equivalente a value.
- Attributi
Eccezioni
value è maggiore di SByte.MaxValue.
Esempio
L'esempio seguente tenta di convertire ogni elemento in una matrice di Char valori in un byte firmato.
char[] chars = { 'a', 'z', '\u0007', '\u0200', '\u1023' };
foreach (char ch in chars)
{
try {
sbyte result = Convert.ToSByte(ch);
Console.WriteLine("{0} is converted to {1}.", ch, result);
}
catch (OverflowException) {
Console.WriteLine("Unable to convert u+{0} to a byte.",
Convert.ToInt16(ch).ToString("X4"));
}
}
// The example displays the following output:
// a is converted to 97.
// z is converted to 122.
// is converted to 7.
// Unable to convert u+00C8 to a byte.
// Unable to convert u+03FF to a byte.
let chars =
[| 'a'; 'z'; '\u0007'; '\u03FF'; '\u7FFF'; '\uFFFE' |]
for ch in chars do
try
let result = Convert.ToSByte ch
printfn $"Converted the {ch.GetType().Name} value '{ch}' to the {result.GetType().Name} value {result}."
with :? OverflowException ->
printfn $"Unable to convert u+{int ch:X4} to an Int32."
// The example displays the following output:
// Converted the Char value 'a' to the SByte value 97.
// Converted the Char value 'z' to the SByte value 122.
// Converted the Char value '' to the SByte value 7.
// Converted the Char value 'Ͽ' to the SByte value 1023.
// Converted the Char value '翿' to the SByte value 32767.
// Converted the Char value '' to the SByte value 65534.
Dim chars() As Char = { "a"c, "z"c, ChrW(7), ChrW(200), ChrW(1023) }
For Each ch As Char in chars
Try
Dim result As SByte = Convert.ToSByte(ch)
Console.WriteLine("{0} is converted to {1}.", ch, result)
Catch e As OverflowException
Console.WriteLine("Unable to convert u+{0} to a byte.", _
AscW(ch).ToString("X4"))
End Try
Next
' The example displays the following output:
' a is converted to 97.
' z is converted to 122.
' is converted to 7.
' Unable to convert u+00C8 to a byte.
' Unable to convert u+03FF to a byte.
Si applica a
ToSByte(DateTime)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
La chiamata di questo metodo genera sempre un'eccezione InvalidCastException.
public:
static System::SByte ToSByte(DateTime value);[System.CLSCompliant(false)]
public static sbyte ToSByte (DateTime value);[<System.CLSCompliant(false)>]
static member ToSByte : DateTime -> sbytePublic Shared Function ToSByte (value As DateTime) As SByteParametri
- value
- DateTime
Valore di data e ora da convertire.
Restituisce
Questa conversione non è supportata. Non vengono restituiti valori.
- Attributi
Eccezioni
Questa conversione non è supportata.
Si applica a
ToSByte(Boolean)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore booleano specificato nell'intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(bool value);[System.CLSCompliant(false)]
public static sbyte ToSByte (bool value);[<System.CLSCompliant(false)>]
static member ToSByte : bool -> sbytePublic Shared Function ToSByte (value As Boolean) As SByteParametri
- value
- Boolean
Valore booleano da convertire.
Restituisce
Il numero 1 se value è true; in caso contrario, 0.
- Attributi
Esempio
Nell'esempio seguente i valori booleani e false i valori true di byte firmati.
bool falseFlag = false;
bool trueFlag = true;
Console.WriteLine("{0} converts to {1}.", falseFlag,
Convert.ToSByte(falseFlag));
Console.WriteLine("{0} converts to {1}.", trueFlag,
Convert.ToSByte(trueFlag));
// The example displays the following output:
// false converts to 0.
// true converts to 1.
let falseFlag = false
let trueFlag = true
printfn $"{falseFlag} converts to {Convert.ToSByte falseFlag}."
printfn $"{trueFlag} converts to {Convert.ToSByte trueFlag}."
// The example displays the following output:
// False converts to 0.
// True converts to 1.
Dim falseFlag As Boolean = False
Dim trueFlag As Boolean = True
Console.WriteLine("{0} converts to {1}.", falseFlag, _
Convert.ToSByte(falseFlag))
Console.WriteLine("{0} converts to {1}.", trueFlag, _
Convert.ToSByte(trueFlag))
' The example displays the following output:
' False converts to 0.
' True converts to 1.
Si applica a
ToSByte(Double)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore del numero a virgola mobile e con precisione doppia specificato in un intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(double value);[System.CLSCompliant(false)]
public static sbyte ToSByte (double value);[<System.CLSCompliant(false)>]
static member ToSByte : double -> sbytePublic Shared Function ToSByte (value As Double) As SByteParametri
- value
- Double
Numero a virgola mobile a precisione doppia da convertire.
Restituisce
value, arrotondato all'intero con segno a 8 bit più vicino. Se value si trova a metà tra due numeri interi, viene restituito il numero intero pari; vale a dire, 4,5 viene convertito in 4, mentre 5,5 viene convertito in 6.
- Attributi
Eccezioni
value è maggiore di SByte.MaxValue o minore di SByte.MinValue.
Esempio
L'esempio seguente tenta di convertire ogni elemento in una matrice di Double valori in un byte firmato.
double[] numbers = { Double.MinValue, -129.5, -12.7, 0, 16,
103.6, 255.0, 1.63509e17, Double.MaxValue};
sbyte result;
foreach (double number in numbers)
{
try {
result = Convert.ToSByte(number);
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
number.GetType().Name, number,
result.GetType().Name, result);
}
catch (OverflowException) {
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.",
number.GetType().Name, number);
}
}
// The example displays the following output:
// The Double value -1.79769313486232E+308 is outside the range of the SByte type.
// The Double value -129.5 is outside the range of the SByte type.
// Converted the Double value -12.7 to the SByte value -13.
// Converted the Double value 0 to the SByte value 0.
// Converted the Double value 16 to the SByte value 16.
// Converted the Double value 103.6 to the SByte value 104.
// The Double value 255 is outside the range of the SByte type.
// The Double value 1.63509E+17 is outside the range of the SByte type.
// The Double value 1.79769313486232E+308 is outside the range of the SByte type.
let values =
[| Double.MinValue; -1.38e10; -1023.299; -12.98
0; 9.113e-16; 103.919; 17834.191; Double.MaxValue |]
for value in values do
try
let result = Convert.ToSByte value
printfn $"Converted the {value.GetType().Name} value '{value}' to the {result.GetType().Name} value {result}."
with :? OverflowException ->
printfn $"{value} is outside the range of the SByte type."
// -1.79769313486232E+308 is outside the range of the SByte type.
// -13800000000 is outside the range of the SByte type.
// Converted the Double value '-1023.299' to the SByte value -1023.
// Converted the Double value '-12.98' to the SByte value -13.
// Converted the Double value '0' to the SByte value 0.
// Converted the Double value '9.113E-16' to the SByte value 0.
// Converted the Double value '103.919' to the SByte value 104.
// Converted the Double value '17834.191' to the SByte value 17834.
// 1.79769313486232E+308 is outside the range of the SByte type.
Dim numbers() As Double = { Double.MinValue, -129.5, -12.7, 0, 16, _
103.6, 255.0, 1.63509e17, Double.MaxValue}
Dim result As SByte
For Each number As Double In numbers
Try
result = Convert.ToSByte(number)
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
number.GetType().Name, number, _
result.GetType().Name, result)
Catch e As OverflowException
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.", _
number.GetType().Name, number)
End Try
Next
' The example displays the following output:
' The Double value -1.79769313486232E+308 is outside the range of the SByte type.
' The Double value -129.5 is outside the range of the SByte type.
' Converted the Double value -12.7 to the SByte value -13.
' Converted the Double value 0 to the SByte value 0.
' Converted the Double value 16 to the SByte value 16.
' Converted the Double value 103.6 to the SByte value 104.
' The Double value 255 is outside the range of the SByte type.
' The Double value 1.63509E+17 is outside the range of the SByte type.
' The Double value 1.79769313486232E+308 is outside the range of the SByte type.
Vedi anche
Si applica a
ToSByte(Int16)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore dell'intero con segno a 16 bit specificato nell'intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(short value);[System.CLSCompliant(false)]
public static sbyte ToSByte (short value);[<System.CLSCompliant(false)>]
static member ToSByte : int16 -> sbytePublic Shared Function ToSByte (value As Short) As SByteParametri
- value
- Int16
Intero con segno a 16 bit da convertire.
Restituisce
Intero con segno a 8 bit equivalente a value.
- Attributi
Eccezioni
value è maggiore di SByte.MaxValue o minore di SByte.MinValue.
Esempio
L'esempio seguente tenta di convertire ogni elemento in una matrice di interi con segno a 16 bit in un byte con segno.
short[] numbers = { Int16.MinValue, -1, 0, 121, 340, Int16.MaxValue };
sbyte result;
foreach (short number in numbers)
{
try {
result = Convert.ToSByte(number);
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
number.GetType().Name, number,
result.GetType().Name, result);
}
catch (OverflowException) {
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.",
number.GetType().Name, number);
}
}
// The example displays the following output:
// The Int16 value -32768 is outside the range of the SByte type.
// Converted the Int16 value -1 to the SByte value -1.
// Converted the Int16 value 0 to the SByte value 0.
// Converted the Int16 value 121 to the SByte value 121.
// The Int16 value 340 is outside the range of the SByte type.
// The Int16 value 32767 is outside the range of the SByte type.
let numbers =
[| Int16.MinValue; -1s; 0s; 121s; 340s; Int16.MaxValue |]
for number in numbers do
let result = Convert.ToSByte number
printfn $"Converted the {number.GetType().Name} value {number} to a {result.GetType().Name} value {result}."
// The example displays the following output:
// Converted the Int16 value -32768 to a Int64 value -32768.
// Converted the Int16 value -1 to a Int64 value -1.
// Converted the Int16 value 0 to a Int64 value 0.
// Converted the Int16 value 121 to a Int64 value 121.
// Converted the Int16 value 340 to a Int64 value 340.
// Converted the Int16 value 32767 to a Int64 value 32767.
Dim numbers() As Short = { Int16.MinValue, -1, 0, 121, 340, Int16.MaxValue }
Dim result As SByte
For Each number As Short In numbers
Try
result = Convert.ToSByte(number)
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
number.GetType().Name, number, _
result.GetType().Name, result)
Catch e As OverflowException
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.", _
number.GetType().Name, number)
End Try
Next
' The example displays the following output:
' The Int16 value -32768 is outside the range of the SByte type.
' Converted the Int16 value -1 to the SByte value -1.
' Converted the Int16 value 0 to the SByte value 0.
' Converted the Int16 value 121 to the SByte value 121.
' The Int16 value 340 is outside the range of the SByte type.
' The Int16 value 32767 is outside the range of the SByte type.
Si applica a
ToSByte(Decimal)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Importante
Questa API non è conforme a CLS.
Converte il valore del numero decimale specificato in un intero con segno a 8 bit equivalente.
public:
static System::SByte ToSByte(System::Decimal value);[System.CLSCompliant(false)]
public static sbyte ToSByte (decimal value);[<System.CLSCompliant(false)>]
static member ToSByte : decimal -> sbytePublic Shared Function ToSByte (value As Decimal) As SByteParametri
- value
- Decimal
Numero decimale da convertire.
Restituisce
value, arrotondato all'intero con segno a 8 bit più vicino. Se value si trova a metà tra due numeri interi, viene restituito il numero intero pari; vale a dire, 4,5 viene convertito in 4, mentre 5,5 viene convertito in 6.
- Attributi
Eccezioni
value è maggiore di SByte.MaxValue o minore di SByte.MinValue.
Esempio
L'esempio seguente tenta di convertire ogni elemento in una matrice di Decimal valori in un byte firmato.
decimal[] numbers = { Decimal.MinValue, -129.5m, -12.7m, 0m, 16m,
103.6m, 255.0m, Decimal.MaxValue };
sbyte result;
foreach (decimal number in numbers)
{
try {
result = Convert.ToSByte(number);
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
number.GetType().Name, number,
result.GetType().Name, result);
}
catch (OverflowException) {
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.",
number.GetType().Name, number);
}
}
// The example displays the following output:
// The Decimal value -79228162514264337593543950335 is outside the range of the SByte type.
// The Decimal value -129.5 is outside the range of the SByte type.
// Converted the Decimal value -12.7 to the SByte value -13.
// Converted the Decimal value 0 to the SByte value 0.
// Converted the Decimal value 16 to the SByte value 16.
// Converted the Decimal value 103.6 to the SByte value 104.
// The Decimal value 255 is outside the range of the SByte type.
// The Decimal value 79228162514264337593543950335 is outside the range of the SByte type.
let values =
[| Decimal.MinValue; -1034.23m; -12m; 0m; 147m
199.55m; 9214.16m; Decimal.MaxValue |]
for value in values do
try
let result = Convert.ToSByte value
printfn $"Converted the {value.GetType().Name} value '{value}' to the {result.GetType().Name} value {result}."
with :? OverflowException ->
printfn $"{value} is outside the range of the SByte type."
// The example displays the following output:
// -79228162514264337593543950335 is outside the range of the SByte type.
// Converted the Decimal value '-1034.23' to the SByte value -1034.
// Converted the Decimal value '-12' to the SByte value -12.
// Converted the Decimal value '0' to the SByte value 0.
// Converted the Decimal value '147' to the SByte value 147.
// Converted the Decimal value '199.55' to the SByte value 200.
// Converted the Decimal value '9214.16' to the SByte value 9214.
// 79228162514264337593543950335 is outside the range of the SByte type.
Dim numbers() As Decimal = { Decimal.MinValue, -129.5d, -12.7d, 0d, 16d, _
103.6d, 255.0d, Decimal.MaxValue }
Dim result As SByte
For Each number As Decimal In numbers
Try
result = Convert.ToSByte(number)
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.", _
number.GetType().Name, number, _
result.GetType().Name, result)
Catch e As OverflowException
Console.WriteLine("The {0} value {1} is outside the range of the SByte type.", _
number.GetType().Name, number)
End Try
Next
' The example displays the following output:
' The Decimal value -79228162514264337593543950335 is outside the range of the SByte type.
' The Decimal value -129.5 is outside the range of the SByte type.
' Converted the Decimal value -12.7 to the SByte value -13.
' Converted the Decimal value 0 to the SByte value 0.
' Converted the Decimal value 16 to the SByte value 16.
' Converted the Decimal value 103.6 to the SByte value 104.
' The Decimal value 255 is outside the range of the SByte type.
' The Decimal value 79228162514264337593543950335 is outside the range of the SByte type.
Vedi anche
Si applica a
Collabora con noi su GitHub
L'origine di questo contenuto è disponibile in GitHub, in cui è anche possibile creare ed esaminare i problemi e le richieste pull. Per ulteriori informazioni, vedere la guida per i collaboratori.
Commenti e suggerimenti
Presto disponibile: nel corso del 2024 verranno dismessi i problemi di GitHub come meccanismo di feedback per il contenuto e verranno sostituiti con un nuovo sistema di feedback. Per altre informazioni, vedere: https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per