Convert.ToSByte Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Convertit une valeur spécifiée en entier signé 8 bits.
Surcharges
| ToSByte(SByte) |
Retourne l'entier signé 8 bits spécifié. Aucune conversion n'est effectuée. |
| ToSByte(String, Int32) |
Convertit la représentation sous forme de chaîne d'un nombre dans une base spécifiée en entier signé 8 bits équivalent. |
| ToSByte(String, IFormatProvider) |
Convertit la représentation sous forme de chaîne spécifiée d'un nombre en entier signé 8 bits équivalent à l'aide des informations de mise en forme spécifiées propres à la culture. |
| ToSByte(Object, IFormatProvider) |
Convertit la valeur de l'objet spécifié en entier signé 8 bits à l'aide des informations de mise en forme spécifiées propres à la culture. |
| ToSByte(UInt64) |
Convertit la valeur de l'entier non signé 64 bits spécifié en entier signé 8 bits équivalent. |
| ToSByte(UInt32) |
Convertit la valeur de l'entier non signé 32 bits spécifié en entier signé 8 bits équivalent. |
| ToSByte(String) |
Convertit la représentation sous forme de chaîne spécifiée d'un nombre en entier signé 8 bits équivalent. |
| ToSByte(Single) |
Convertit la valeur du nombre à virgule flottante simple précision spécifié en entier signé 8 bits équivalent. |
| ToSByte(Object) |
Convertit la valeur de l'objet spécifié en entier signé 8 bits. |
| ToSByte(UInt16) |
Convertit la valeur de l'entier non signé 16 bits spécifié en entier signé 8 bits équivalent. |
| ToSByte(Int32) |
Convertit la valeur de l'entier signé 32 bits spécifié en entier signé 8 bits équivalent. |
| ToSByte(Int64) |
Convertit la valeur de l'entier 64 bits signé spécifié en entier 8 bits signé équivalent. |
| ToSByte(Byte) |
Convertit la valeur de l'entier non signé 8 bits spécifié en entier signé 8 bits équivalent. |
| ToSByte(Char) |
Convertit la valeur du caractère Unicode spécifié en entier signé 8 bits équivalent. |
| ToSByte(DateTime) |
L'appel de cette méthode lève toujours InvalidCastException. |
| ToSByte(Boolean) |
Convertit la valeur booléenne spécifiée en entier signé 8 bits équivalent. |
| ToSByte(Double) |
Convertit la valeur du nombre à virgule flottante double précision spécifié en entier signé 8 bits équivalent. |
| ToSByte(Int16) |
Convertit la valeur de l'entier signé 16 bits spécifié en entier signé 8 bits équivalent. |
| ToSByte(Decimal) |
Convertit la valeur du nombre décimal spécifié en entier signé 8 bits équivalent. |
ToSByte(SByte)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Retourne l'entier signé 8 bits spécifié. Aucune conversion n'est effectuée.
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 SByteParamètres
- value
- SByte
Entier signé 8 bits à retourner.
Retours
value est retourné sans modification.
- Attributs
S’applique à
ToSByte(String, Int32)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la représentation sous forme de chaîne d'un nombre dans une base spécifiée en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- String
Chaîne contenant le nombre à convertir.
- fromBase
- Int32
Base du nombre figurant dans value, qui doit correspondre à 2, 8, 10 ou 16.
Retours
Entier signé 8 bits équivalent au nombre dans value, ou 0 (zéro) si value est null.
- Attributs
Exceptions
fromBase n’a pas la valeur 2, 8, 10 ou 16.
- ou -
value, qui représente un nombre signé autre qu’en base 10, est préfixé avec un signe négatif.
value a la valeur Empty.
value contient un caractère qui n’est pas un chiffre valide dans la base spécifiée par fromBase. Le message d’exception indique qu’il n’y a pas de chiffres à convertir si le premier caractère dans value n’est pas valide ; sinon, le message indique que value contient des caractères de fin non valides.
value, qui représente un nombre signé autre qu’en base 10, est préfixé avec un signe négatif.
- ou -
value représente un nombre inférieur à SByte.MinValue ou supérieur à SByte.MaxValue.
Exemples
L’exemple suivant tente d’interpréter les éléments d’un tableau de chaînes en tant que représentation binaire, octale et hexadécimale de valeurs numériques afin de les convertir en octets non signés.
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
Remarques
Si fromBase est 16, vous pouvez préfixer le nombre spécifié par le value paramètre par « 0x » ou « 0X ».
Étant donné que le signe négatif n’est pas pris en charge pour les représentations numériques autres que la base 10, la ToSByte(String, Int32) méthode suppose que les nombres négatifs utilisent la représentation complémentaire de deux. En d’autres termes, la méthode interprète toujours le bit d’ordre élevé d’un octet (bit 7) comme son bit de signe. Par conséquent, il est possible d’écrire du code dans lequel un nombre non-base 10 qui est hors de la plage du type de SByte données est converti SByte en valeur sans que la méthode lève une exception. L’exemple suivant convertit en MaxValue sa représentation de chaîne hexadécimale, puis appelle la ToSByte(String, Int32) méthode . Au lieu de lever une exception, la méthode affiche le message « 0xff convertit en -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
Lors de l’exécution d’opérations binaires ou de conversions numériques, il incombe toujours au développeur de vérifier qu’une méthode utilise la représentation numérique appropriée pour interpréter une valeur particulière. Comme l’illustre l’exemple suivant, vous pouvez vous assurer que la méthode gère correctement les dépassements de capacité en déterminant d’abord si une valeur représente un type non signé ou signé lors de sa conversion en sa représentation de chaîne hexadécimale. Lève une exception si la valeur d’origine était un type non signé, mais que la conversion en octet signé génère une valeur dont le bit de signe est activé.
// 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.
S’applique à
ToSByte(String, IFormatProvider)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la représentation sous forme de chaîne spécifiée d'un nombre en entier signé 8 bits équivalent à l'aide des informations de mise en forme spécifiées propres à la culture.
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 SByteParamètres
- value
- String
Chaîne contenant le nombre à convertir.
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture.
Retours
Entier signé 8 bits équivalent à value.
- Attributs
Exceptions
value a la valeur null.
value n’est pas constitué d’un signe facultatif suivi d’une séquence de chiffres (0 à 9).
value représente un nombre inférieur à SByte.MinValue ou supérieur à SByte.MaxValue.
Exemples
L’exemple suivant convertit des représentations sous forme de chaîne de SByte valeurs avec la méthode, à l’aide ToSByte d’un IFormatProvider objet .
// 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
Remarques
providerest un IFormatProvider instance qui obtient un NumberFormatInfo objet. L’objet NumberFormatInfo fournit des informations spécifiques à la culture sur le format de value. Si provider est null, le NumberFormatInfo pour la culture actuelle est utilisé.
Si vous préférez ne pas gérer d’exception si la conversion échoue, vous pouvez appeler la méthode à la SByte.TryParse place. Elle retourne une Boolean valeur qui indique si la conversion a réussi ou échoué.
Voir aussi
S’applique à
ToSByte(Object, IFormatProvider)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur de l'objet spécifié en entier signé 8 bits à l'aide des informations de mise en forme spécifiées propres à la culture.
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 SByteParamètres
- value
- Object
Objet qui implémente l'interface IConvertible.
- provider
- IFormatProvider
Objet qui fournit des informations de mise en forme propres à la culture.
Retours
Entier signé 8 bits équivalent à value, ou zéro si value est null.
- Attributs
Exceptions
value n’a pas un format approprié.
value représente un nombre inférieur à SByte.MinValue ou supérieur à SByte.MaxValue.
Exemples
L’exemple suivant définit une ByteString classe qui stocke les octets signés et non signés sous forme de chaînes hexadécimales, ainsi qu’un champ qui indique le signe de l’octet. La classe ByteString implémente l’interface IConvertible. Sa IConvertible.ToSByte méthode appelle la Parse(String, IFormatProvider) méthode pour effectuer la conversion. En cas d’échec, il lève un OverflowException.
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
L’exemple suivant montre comment l’implémentation IConvertible.ToSByte de la ByteString classe est appelée par la Convert.ToSByte(Object, IFormatProvider) méthode .
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.
Remarques
provider permet à l’utilisateur de spécifier des informations de conversion spécifiques à la culture sur le contenu de value. Par exemple, si value est un String qui représente un nombre, provider peut fournir des informations spécifiques à la culture sur la notation utilisée pour représenter ce nombre.
Les types de base ignorent provider; toutefois, le paramètre peut être utilisé si value est un type défini par l’utilisateur qui implémente l’interface IConvertible .
S’applique à
ToSByte(UInt64)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur de l'entier non signé 64 bits spécifié en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- UInt64
Entier non signé 64 bits à convertir.
Retours
Entier signé 8 bits équivalent à value.
- Attributs
Exceptions
value est supérieur à SByte.MaxValue ou inférieur à SByte.MinValue.
Exemples
L’exemple suivant tente de convertir chaque élément d’un tableau d’entiers longs en octet signé.
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.
S’applique à
ToSByte(UInt32)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur de l'entier non signé 32 bits spécifié en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- UInt32
Entier non signé 32 bits à convertir.
Retours
Entier signé 8 bits équivalent à value.
- Attributs
Exceptions
value est supérieur à SByte.MaxValue ou inférieur à SByte.MinValue.
Exemples
L’exemple suivant tente de convertir chaque élément d’un tableau d’entiers en octet signé.
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.
S’applique à
ToSByte(String)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la représentation sous forme de chaîne spécifiée d'un nombre en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- String
Chaîne contenant le nombre à convertir.
Retours
Entier signé 8 bits équivalent au nombre dans value, ou 0 (zéro) si value est null.
- Attributs
Exceptions
value n’est pas constitué d’un signe facultatif suivi d’une séquence de chiffres (0 à 9).
value représente un nombre inférieur à SByte.MinValue ou supérieur à SByte.MaxValue.
Exemples
L’exemple suivant convertit des représentations sous forme de chaîne de SByte valeurs avec la méthode , à l’aide de la ToSByte mise en forme par défaut.
// 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
Remarques
L’utilisation de la ToSByte(String) méthode équivaut à passer value à la SByte.Parse(String) méthode . value est interprété à l’aide des conventions de mise en forme de la culture actuelle.
Si vous préférez ne pas gérer une exception si la conversion échoue, vous pouvez appeler la méthode à la SByte.TryParse place. Elle retourne une Boolean valeur qui indique si la conversion a réussi ou échoué.
Voir aussi
S’applique à
ToSByte(Single)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur du nombre à virgule flottante simple précision spécifié en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- Single
Nombre à virgule flottante simple précision à convertir.
Retours
value, arrondi à l’entier signé 8 bits le plus proche. Si value se trouve entre deux nombres entiers, le nombre pair est retourné (par exemple, 4,5 est converti en 4 et 5,5 en 6).
- Attributs
Exceptions
value est supérieur à SByte.MaxValue ou inférieur à SByte.MinValue.
Exemples
L’exemple suivant tente de convertir chaque élément d’un tableau de Single valeurs en octet signé.
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.
Voir aussi
S’applique à
ToSByte(Object)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur de l'objet spécifié en entier signé 8 bits.
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 SByteParamètres
- value
- Object
Objet qui implémente l'interface IConvertible ou null.
Retours
Entier signé 8 bits équivalent à value, ou zéro si value est null.
- Attributs
Exceptions
value n’a pas un format approprié.
value représente un nombre inférieur à SByte.MinValue ou supérieur à SByte.MaxValue.
Exemples
L’exemple suivant tente de convertir chaque élément d’un tableau d’objets en octet signé.
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.
Remarques
La valeur de retour est le résultat de l’appel de la IConvertible.ToSByte méthode du type sous-jacent de value.
S’applique à
ToSByte(UInt16)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur de l'entier non signé 16 bits spécifié en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- UInt16
Entier non signé 16 bits à convertir.
Retours
Entier signé 8 bits équivalent à value.
- Attributs
Exceptions
value est supérieur à SByte.MaxValue.
Exemples
L’exemple suivant tente de convertir chaque élément d’un tableau d’entiers 16 bits non signés en octets signés.
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.
S’applique à
ToSByte(Int32)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur de l'entier signé 32 bits spécifié en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- Int32
Entier signé 32 bits à convertir.
Retours
Entier signé 8 bits équivalent à value.
- Attributs
Exceptions
value est supérieur à SByte.MaxValue ou inférieur à SByte.MinValue.
Exemples
L’exemple suivant tente de convertir chaque élément d’un tableau d’entiers signés en octet signé.
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.
S’applique à
ToSByte(Int64)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur de l'entier 64 bits signé spécifié en entier 8 bits signé équivalent.
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 SByteParamètres
- value
- Int64
Entier signé 64 bits à convertir.
Retours
Entier signé 8 bits équivalent à value.
- Attributs
Exceptions
value est supérieur à SByte.MaxValue ou inférieur à SByte.MinValue.
Exemples
L’exemple suivant tente de convertir chaque élément d’un tableau d’entiers longs en octets signés.
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.
S’applique à
ToSByte(Byte)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur de l'entier non signé 8 bits spécifié en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- Byte
Entier non signé 8 bits à convertir.
Retours
Entier signé 8 bits équivalent à value.
- Attributs
Exceptions
value est supérieur à SByte.MaxValue.
Exemples
L’exemple suivant tente de convertir chaque élément d’un tableau d’octets en octets signé.
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.
S’applique à
ToSByte(Char)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur du caractère Unicode spécifié en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- Char
Caractère Unicode à convertir.
Retours
Entier signé 8 bits équivalent à value.
- Attributs
Exceptions
value est supérieur à SByte.MaxValue.
Exemples
L’exemple suivant tente de convertir chaque élément d’un tableau de Char valeurs en octet signé.
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.
S’applique à
ToSByte(DateTime)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
L'appel de cette méthode lève toujours 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 SByteParamètres
- value
- DateTime
Valeur de date et heure à convertir.
Retours
Cette conversion n'est pas prise en charge. Aucune valeur n’est retournée.
- Attributs
Exceptions
Cette conversion n'est pas prise en charge.
S’applique à
ToSByte(Boolean)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur booléenne spécifiée en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- Boolean
Valeur booléenne à convertir.
Retours
Chiffre 1, si value est true ; sinon, 0.
- Attributs
Exemples
L’exemple suivant convertit les valeurs booléennes et false en valeurs true d’octets signées.
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.
S’applique à
ToSByte(Double)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur du nombre à virgule flottante double précision spécifié en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- Double
Nombre à virgule flottante double précision à convertir.
Retours
value, arrondi à l’entier signé 8 bits le plus proche. Si value se trouve entre deux nombres entiers, le nombre pair est retourné (par exemple, 4,5 est converti en 4 et 5,5 en 6).
- Attributs
Exceptions
value est supérieur à SByte.MaxValue ou inférieur à SByte.MinValue.
Exemples
L’exemple suivant tente de convertir chaque élément d’un tableau de Double valeurs en octet signé.
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.
Voir aussi
S’applique à
ToSByte(Int16)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur de l'entier signé 16 bits spécifié en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- Int16
Entier signé 16 bits à convertir.
Retours
Entier signé 8 bits équivalent à value.
- Attributs
Exceptions
value est supérieur à SByte.MaxValue ou inférieur à SByte.MinValue.
Exemples
L’exemple suivant tente de convertir chaque élément d’un tableau d’entiers 16 bits signés en octets signés.
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.
S’applique à
ToSByte(Decimal)
- Source:
- Convert.cs
- Source:
- Convert.cs
- Source:
- Convert.cs
Important
Cette API n’est pas conforme CLS.
Convertit la valeur du nombre décimal spécifié en entier signé 8 bits équivalent.
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 SByteParamètres
- value
- Decimal
Nombre décimal à convertir.
Retours
value, arrondi à l’entier signé 8 bits le plus proche. Si value se trouve entre deux nombres entiers, le nombre pair est retourné (par exemple, 4,5 est converti en 4 et 5,5 en 6).
- Attributs
Exceptions
value est supérieur à SByte.MaxValue ou inférieur à SByte.MinValue.
Exemples
L’exemple suivant tente de convertir chaque élément d’un tableau de Decimal valeurs en octet signé.
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.
Voir aussi
S’applique à
Collaborer avec nous sur GitHub
La source de ce contenu se trouve sur GitHub, où vous pouvez également créer et examiner les problèmes et les demandes de tirage. Pour plus d’informations, consultez notre guide du contributeur.
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour