Convert.ToSByte Metoda
Definicja
Ważne
Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.
Konwertuje określoną wartość na liczbę całkowitą z podpisem 8-bitowym.
Przeciążenia
| ToSByte(SByte) |
Zwraca określoną liczbę całkowitą z podpisem 8-bitowym; nie jest wykonywana żadna rzeczywista konwersja. |
| ToSByte(String, Int32) |
Konwertuje reprezentację ciągu liczby w określonej bazie na równoważną liczbę z podpisem 8-bitowym. |
| ToSByte(String, IFormatProvider) |
Konwertuje określoną reprezentację ciągu liczby na równoważną liczbę z podpisem 8-bitowym przy użyciu określonych informacji o formatowaniu specyficznym dla kultury. |
| ToSByte(Object, IFormatProvider) |
Konwertuje wartość określonego obiektu na liczbę całkowitą z podpisem 8-bitowym przy użyciu określonych informacji o formatowaniu specyficznym dla kultury. |
| ToSByte(UInt64) |
Konwertuje wartość określonej 64-bitowej liczby całkowitej bez znaku na równoważną liczbę całkowitą podpisaną 8-bitową. |
| ToSByte(UInt32) |
Konwertuje wartość określonej 32-bitowej liczby całkowitej bez znaku na równoważną liczbę całkowitą podpisaną 8-bitową. |
| ToSByte(String) |
Konwertuje określoną reprezentację ciągu liczby na równoważną liczbę z podpisem 8-bitowym. |
| ToSByte(Single) |
Konwertuje wartość określonej liczby zmiennoprzecinkowej o pojedynczej precyzji na równoważną 8-bitową liczbę całkowitą ze znakiem. |
| ToSByte(Object) |
Konwertuje wartość określonego obiektu na liczbę całkowitą z podpisem 8-bitowym. |
| ToSByte(UInt16) |
Konwertuje wartość określonej 16-bitowej liczby całkowitej bez znaku na równoważną liczbę całkowitą podpisaną 8-bitową. |
| ToSByte(Int32) |
Konwertuje wartość określonej 32-bitowej liczby całkowitej podpisanej na równoważną liczbę całkowitą podpisaną 8-bitową. |
| ToSByte(Int64) |
Konwertuje wartość określonej 64-bitowej liczby całkowitej podpisanej na równoważną liczbę całkowitą podpisaną 8-bitową. |
| ToSByte(Byte) |
Konwertuje wartość określonej 8-bitowej liczby całkowitej bez znaku na równoważną liczbę całkowitą podpisaną 8-bitową. |
| ToSByte(Char) |
Konwertuje wartość określonego znaku Unicode na równoważną liczbę całkowitą z podpisem 8-bitowym. |
| ToSByte(DateTime) |
Wywołanie tej metody zawsze zgłasza błąd InvalidCastException. |
| ToSByte(Boolean) |
Konwertuje określoną wartość logiczną na równoważną liczbę całkowitą z podpisem 8-bitowym. |
| ToSByte(Double) |
Konwertuje wartość określonej liczby zmiennoprzecinkowej o podwójnej precyzji na równoważną 8-bitową liczbę całkowitą ze znakiem. |
| ToSByte(Int16) |
Konwertuje wartość określonej 16-bitowej liczby całkowitej podpisanej na równoważną liczbę całkowitą podpisaną 8-bitową. |
| ToSByte(Decimal) |
Konwertuje wartość określonej liczby dziesiętnej na równoważną liczbę z podpisem 8-bitowym. |
ToSByte(SByte)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Zwraca określoną liczbę całkowitą z podpisem 8-bitowym; nie jest wykonywana żadna rzeczywista konwersja.
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 SByteParametry
- value
- SByte
Liczba całkowita z podpisem 8-bitowym, która ma być zwracana.
Zwraca
value jest zwracany bez zmian.
- Atrybuty
Dotyczy
ToSByte(String, Int32)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje reprezentację ciągu liczby w określonej bazie na równoważną liczbę z podpisem 8-bitowym.
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 SByteParametry
- value
- String
Ciąg zawierający liczbę, którą należy przekształcić.
- fromBase
- Int32
Podstawa liczby w valuewartości , która musi mieć wartość 2, 8, 10 lub 16.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna liczbie w valueliczbie lub 0 (zero), jeśli value jest to null.
- Atrybuty
Wyjątki
fromBase nie jest 2, 8, 10 lub 16.
-lub-
value, który reprezentuje niepodstawowy 10 podpisany numer, jest poprzedzony znakiem ujemnym.
value to Empty.
value zawiera znak, który nie jest prawidłową cyfrą w bazie określonej przez fromBase. Komunikat o wyjątku wskazuje, że nie ma cyfr do konwersji, jeśli pierwszy znak jest value nieprawidłowy. W przeciwnym razie komunikat wskazuje, że value zawiera nieprawidłowe znaki końcowe.
value, który reprezentuje niepodstawowy 10 podpisany numer, jest poprzedzony znakiem ujemnym.
-lub-
value reprezentuje liczbę, która jest mniejsza niż SByte.MinValue lub większa niż SByte.MaxValue.
Przykłady
W poniższym przykładzie podjęto próbę zinterpretowania elementów w tablicy ciągów jako binarnej, ósemkowej i szesnastkowej reprezentacji wartości liczbowych w celu przekonwertowania ich na niepodpisane bajty.
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
Uwagi
Jeśli fromBase wartość to 16, możesz prefiks liczby określonej przez value parametr o wartości "0x" lub "0X".
Ponieważ znak ujemny nie jest obsługiwany w przypadku reprezentacji liczbowych innych niż base 10, metoda zakłada, ToSByte(String, Int32) że liczby ujemne używają reprezentacji uzupełniającej dwóch. Innymi słowy, metoda zawsze interpretuje bit o wysokiej kolejności bajtu (bit 7) jako bit znaku. W związku z tym można napisać kod, w którym liczba niepodstawna 10, która jest poza zakresem SByte typu danych, jest konwertowana na SByte wartość bez metody zgłaszającej wyjątek. Poniższy przykład konwertuje MaxValue na reprezentację ciągu szesnastkowego, a następnie wywołuje metodę ToSByte(String, Int32) . Zamiast zgłaszać wyjątek, metoda wyświetla komunikat "0xff konwertuje na -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
Podczas wykonywania operacji binarnych lub przeliczeń liczbowych programista ma obowiązek sprawdzić, czy metoda używa reprezentacji liczbowej odpowiedniej do zinterpretowania określonej wartości. Jak pokazano w poniższym przykładzie, możesz upewnić się, że metoda odpowiednio obsługuje przepełnienia, określając najpierw, czy wartość reprezentuje niepodpisany, czy podpisany typ podczas konwertowania go na reprezentację ciągu szesnastkowego. Zgłasza wyjątek, jeśli oryginalna wartość była typem niepodpisanym, ale konwersja z powrotem do podpisanego bajtu daje wartość, której bit znaku jest włączony.
// 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.
Dotyczy
ToSByte(String, IFormatProvider)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje określoną reprezentację ciągu liczby na równoważną liczbę z podpisem 8-bitowym przy użyciu określonych informacji o formatowaniu specyficznym dla kultury.
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 SByteParametry
- value
- String
Ciąg zawierający liczbę, którą należy przekształcić.
- provider
- IFormatProvider
Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.
- Atrybuty
Wyjątki
value to null.
value nie składa się z opcjonalnego znaku, po którym następuje sekwencja cyfr (od 0 do 9).
value reprezentuje liczbę, która jest mniejsza niż SByte.MinValue lub większa niż SByte.MaxValue.
Przykłady
Poniższy przykład konwertuje reprezentacje ciągów SByte wartości za ToSByte pomocą metody przy użyciu IFormatProvider obiektu.
// 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
Uwagi
provider
IFormatProvider to wystąpienie, które uzyskuje NumberFormatInfo obiekt. Obiekt NumberFormatInfo udostępnia informacje specyficzne dla kultury dotyczące formatu .value Jeśli provider jest to null, NumberFormatInfo jest używana wartość dla bieżącej kultury.
Jeśli wolisz nie obsługiwać wyjątku, jeśli konwersja nie powiedzie się, możesz wywołać metodę SByte.TryParse zamiast tego. Zwraca wartość wskazującą, czy konwersja zakończyła się powodzeniem Boolean , czy niepowodzeniem.
Zobacz też
Dotyczy
ToSByte(Object, IFormatProvider)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonego obiektu na liczbę całkowitą z podpisem 8-bitowym przy użyciu określonych informacji o formatowaniu specyficznym dla kultury.
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 SByteParametry
- value
- Object
Obiekt, który implementuje IConvertible interfejs.
- provider
- IFormatProvider
Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna valuewartościom , lub zero, jeśli value jest to null.
- Atrybuty
Wyjątki
value nie jest w odpowiednim formacie.
value reprezentuje liczbę, która jest mniejsza niż SByte.MinValue lub większa niż SByte.MaxValue.
Przykłady
W poniższym przykładzie zdefiniowano klasę ByteString , która przechowuje zarówno podpisane, jak i niepodpisane bajty jako ciągi szesnastkowe wraz z polem wskazującym znak bajtu. Klasa ByteString implementuje interfejs IConvertible. Metoda IConvertible.ToSByte wywołuje metodę Parse(String, IFormatProvider) do przeprowadzenia konwersji. Jeśli błąd zakończy się niepowodzeniem, zgłasza błąd 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
W poniższym przykładzie pokazano, jak implementacja IConvertible.ToSByteByteString klasy jest wywoływana przez metodę Convert.ToSByte(Object, IFormatProvider) .
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.
Uwagi
provider umożliwia użytkownikowi określenie informacji o konwersji specyficznej dla kultury na temat zawartości elementu value. Jeśli na przykład value jest to liczba reprezentująca String liczbę, provider może dostarczyć informacji specyficznych dla kultury dotyczących notacji użytej do reprezentowania tej liczby.
Typy podstawowe ignorują provider, ale parametr może być używany, jeśli value jest typem zdefiniowanym przez użytkownika, który implementuje IConvertible interfejs.
Dotyczy
ToSByte(UInt64)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonej 64-bitowej liczby całkowitej bez znaku na równoważną liczbę całkowitą podpisaną 8-bitową.
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 SByteParametry
- value
- UInt64
64-bitowa liczba całkowita bez znaku, która ma być konwertowana.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.
- Atrybuty
Wyjątki
value wartość jest większa niż SByte.MaxValue lub mniejsza niż SByte.MinValue.
Przykłady
Poniższy przykład próbuje przekonwertować każdy element w tablicy długich liczb całkowitych na podpisany bajt.
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.
Dotyczy
ToSByte(UInt32)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonej 32-bitowej liczby całkowitej bez znaku na równoważną liczbę całkowitą podpisaną 8-bitową.
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 SByteParametry
- value
- UInt32
32-bitowa liczba całkowita bez znaku, która ma być konwertowana.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.
- Atrybuty
Wyjątki
value wartość jest większa niż SByte.MaxValue lub mniejsza niż SByte.MinValue.
Przykłady
Poniższy przykład próbuje przekonwertować każdy element w tablicy całkowitej na podpisany bajt.
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.
Dotyczy
ToSByte(String)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje określoną reprezentację ciągu liczby na równoważną liczbę z podpisem 8-bitowym.
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 SByteParametry
- value
- String
Ciąg zawierający liczbę, którą należy przekształcić.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna liczbie w valueelemencie , lub 0 (zero), jeśli wartość to null.
- Atrybuty
Wyjątki
value nie składa się z opcjonalnego znaku, po którym następuje sekwencja cyfr (od 0 do 9).
value reprezentuje liczbę, która jest mniejsza niż SByte.MinValue lub większa niż SByte.MaxValue.
Przykłady
Poniższy przykład konwertuje reprezentacje ciągów SByte wartości za pomocą metody przy użyciu formatowania domyślnego ToSByte .
// 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
Uwagi
ToSByte(String) Użycie metody jest równoważne przekazywaniu valueSByte.Parse(String) do metody .
value program jest interpretowany przy użyciu konwencji formatowania bieżącej kultury.
Jeśli wolisz nie obsługiwać wyjątku, jeśli konwersja nie powiedzie się, możesz wywołać metodę SByte.TryParse zamiast tego. Zwraca wartość wskazującą, czy konwersja zakończyła się powodzeniem Boolean , czy niepowodzeniem.
Zobacz też
Dotyczy
ToSByte(Single)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonej liczby zmiennoprzecinkowej o pojedynczej precyzji na równoważną 8-bitową liczbę całkowitą ze znakiem.
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 SByteParametry
- value
- Single
Liczba zmiennoprzecinkowa pojedynczej precyzji, która ma zostać przekształcona.
Zwraca
value, zaokrąglone do najbliższej 8-bitowej liczby całkowitej ze znakiem. Jeśli value jest w połowie między dwiema liczbami całkowitymi, zwracana jest liczba parzysta, czyli 4,5 jest konwertowana na 4, a wartość 5,5 jest konwertowana na 6.
- Atrybuty
Wyjątki
value wartość jest większa niż SByte.MaxValue lub mniejsza niż SByte.MinValue.
Przykłady
Poniższy przykład próbuje przekonwertować każdy element w tablicy Single wartości na podpisany bajt.
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.
Zobacz też
Dotyczy
ToSByte(Object)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonego obiektu na liczbę całkowitą z podpisem 8-bitowym.
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 SByteParametry
- value
- Object
Obiekt, który implementuje IConvertible interfejs lub null.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna valuewartościom , lub zero, jeśli value jest to null.
- Atrybuty
Wyjątki
value nie jest w odpowiednim formacie.
value reprezentuje liczbę, która jest mniejsza niż SByte.MinValue lub większa niż SByte.MaxValue.
Przykłady
Poniższy przykład próbuje przekonwertować każdy element w tablicy obiektów na podpisany bajt.
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.
Uwagi
Wartość zwracana jest wynikiem wywołania IConvertible.ToSByte metody bazowego typu value.
Dotyczy
ToSByte(UInt16)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonej 16-bitowej liczby całkowitej bez znaku na równoważną liczbę całkowitą podpisaną 8-bitową.
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 SByteParametry
- value
- UInt16
16-bitowa liczba całkowita bez znaku, która ma zostać przekształcona.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.
- Atrybuty
Wyjątki
value wartość jest większa niż SByte.MaxValue.
Przykłady
Poniższy przykład próbuje przekonwertować każdy element w tablicy niepodpisanych liczb całkowitych 16-bitowych na podpisany bajt.
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.
Dotyczy
ToSByte(Int32)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonej 32-bitowej liczby całkowitej podpisanej na równoważną liczbę całkowitą podpisaną 8-bitową.
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 SByteParametry
- value
- Int32
Liczba całkowita z podpisem 32-bitowym do przekonwertowania.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.
- Atrybuty
Wyjątki
value wartość jest większa niż SByte.MaxValue lub mniejsza niż SByte.MinValue.
Przykłady
Poniższy przykład próbuje przekonwertować każdy element w tablicy podpisanych liczb całkowitych na podpisany bajt.
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.
Dotyczy
ToSByte(Int64)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonej 64-bitowej liczby całkowitej podpisanej na równoważną liczbę całkowitą podpisaną 8-bitową.
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 SByteParametry
- value
- Int64
Liczba całkowita z podpisem 64-bitowym do przekonwertowania.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.
- Atrybuty
Wyjątki
value wartość jest większa niż SByte.MaxValue lub mniejsza niż SByte.MinValue.
Przykłady
Poniższy przykład próbuje przekonwertować każdy element w tablicy długich liczb całkowitych na podpisany bajt.
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.
Dotyczy
ToSByte(Byte)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonej 8-bitowej liczby całkowitej bez znaku na równoważną liczbę całkowitą podpisaną 8-bitową.
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 SByteParametry
- value
- Byte
8-bitowa liczba całkowita bez znaku, która ma być konwertowana.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.
- Atrybuty
Wyjątki
value wartość jest większa niż SByte.MaxValue.
Przykłady
Poniższy przykład próbuje przekonwertować każdy element w tablicy bajtów na podpisany bajt.
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.
Dotyczy
ToSByte(Char)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonego znaku Unicode na równoważną liczbę całkowitą z podpisem 8-bitowym.
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 SByteParametry
- value
- Char
Znak Unicode, który ma zostać przekształcony.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.
- Atrybuty
Wyjątki
value wartość jest większa niż SByte.MaxValue.
Przykłady
Poniższy przykład próbuje przekonwertować każdy element w tablicy Char wartości na podpisany bajt.
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.
Dotyczy
ToSByte(DateTime)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Wywołanie tej metody zawsze zgłasza błąd 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 SByteParametry
- value
- DateTime
Wartość daty i godziny, która ma zostać przekształcona.
Zwraca
Ta konwersja nie jest obsługiwana. Nie jest zwracana żadna wartość.
- Atrybuty
Wyjątki
Ta konwersja nie jest obsługiwana.
Dotyczy
ToSByte(Boolean)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje określoną wartość logiczną na równoważną liczbę całkowitą z podpisem 8-bitowym.
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 SByteParametry
- value
- Boolean
Wartość logiczna, która ma zostać przekształcona.
Zwraca
Liczba 1, jeśli value to true; w przeciwnym razie, 0.
- Atrybuty
Przykłady
Poniższy przykład konwertuje wartości true logiczne i false na podpisane wartości bajtów.
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.
Dotyczy
ToSByte(Double)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonej liczby zmiennoprzecinkowej o podwójnej precyzji na równoważną 8-bitową liczbę całkowitą ze znakiem.
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 SByteParametry
- value
- Double
Liczba zmiennoprzecinkowa podwójnej precyzji, która ma zostać przekształcona.
Zwraca
value, zaokrąglone do najbliższej 8-bitowej liczby całkowitej ze znakiem. Jeśli value jest w połowie między dwiema liczbami całkowitymi, zwracana jest liczba parzysta, czyli 4,5 jest konwertowana na 4, a wartość 5,5 jest konwertowana na 6.
- Atrybuty
Wyjątki
value wartość jest większa niż SByte.MaxValue lub mniejsza niż SByte.MinValue.
Przykłady
Poniższy przykład próbuje przekonwertować każdy element w tablicy Double wartości na podpisany bajt.
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.
Zobacz też
Dotyczy
ToSByte(Int16)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonej 16-bitowej liczby całkowitej podpisanej na równoważną liczbę całkowitą podpisaną 8-bitową.
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 SByteParametry
- value
- Int16
16-bitowa liczba całkowita ze znakiem, która ma zostać przekształcona.
Zwraca
Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.
- Atrybuty
Wyjątki
value wartość jest większa niż SByte.MaxValue lub mniejsza niż SByte.MinValue.
Przykłady
Poniższy przykład próbuje przekonwertować każdy element w tablicy podpisanych 16-bitowych liczb całkowitych na podpisany bajt.
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.
Dotyczy
ToSByte(Decimal)
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
- Źródło:
- Convert.cs
Ważne
Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Konwertuje wartość określonej liczby dziesiętnej na równoważną liczbę z podpisem 8-bitowym.
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 SByteParametry
- value
- Decimal
Liczba dziesiętna, która ma zostać przekształcona.
Zwraca
value, zaokrąglone do najbliższej 8-bitowej liczby całkowitej ze znakiem. Jeśli value jest w połowie między dwiema liczbami całkowitymi, zwracana jest liczba parzysta, czyli 4,5 jest konwertowana na 4, a wartość 5,5 jest konwertowana na 6.
- Atrybuty
Wyjątki
value wartość jest większa niż SByte.MaxValue lub mniejsza niż SByte.MinValue.
Przykłady
Poniższy przykład próbuje przekonwertować każdy element w tablicy Decimal wartości na podpisany bajt.
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.
Zobacz też
Dotyczy
Współpracuj z nami w serwisie GitHub
Źródło tej zawartości można znaleźć w witrynie GitHub, gdzie można również tworzyć i przeglądać problemy i żądania ściągnięcia. Więcej informacji znajdziesz w naszym przewodniku dla współtwórców.
