Convert.ToSByte Metoda

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

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

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.

[System.CLSCompliant(false)]
public static sbyte ToSByte (sbyte value);

Parametry

value

SByte

Liczba całkowita z podpisem 8-bitowym, która ma być zwracana.

Zwraca

SByte

value jest zwracany bez zmian.

Atrybuty

CLSCompliantAttribute

ToSByte(String, Int32)

Ź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.

[System.CLSCompliant(false)]
public static sbyte ToSByte (string? value, int fromBase);

Parametry

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

SByte

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

CLSCompliantAttribute

Wyjątki

ArgumentException

fromBase nie jest 2, 8, 10 lub 16.

-lub-

value, który reprezentuje niepodstawowy 10 podpisany numer, jest poprzedzony znakiem ujemnym.

ArgumentOutOfRangeException

value to Empty.

FormatException

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.

OverflowException

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

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);
}

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.

ToSByte(String, IFormatProvider)

Ź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.

[System.CLSCompliant(false)]
public static sbyte ToSByte (string value, IFormatProvider? provider);

Parametry

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

SByte

Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.

Atrybuty

CLSCompliantAttribute

Wyjątki

ArgumentNullException

value to null.

FormatException

value nie składa się z opcjonalnego znaku, po którym następuje sekwencja cyfr (od 0 do 9).

OverflowException

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 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
*/

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ż

• Parse(String)

ToSByte(Object, IFormatProvider)

Ź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.

[System.CLSCompliant(false)]
public static sbyte ToSByte (object? value, IFormatProvider? provider);

Parametry

value

Object

Obiekt, który implementuje IConvertible interfejs.

provider

IFormatProvider

Obiekt, który dostarcza informacje o formatowaniu specyficzne dla kultury.

Zwraca

SByte

Liczba całkowita z podpisem 8-bitowym, która jest równoważna valuewartościom , lub zero, jeśli value jest to null.

Atrybuty

CLSCompliantAttribute

Wyjątki

FormatException

value nie jest w odpowiednim formacie.

InvalidCastException

value nie implementuje interfejsu IConvertible .

-lub-

Konwersja nie jest obsługiwana.

OverflowException

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));
   }
}

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.

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.

ToSByte(UInt64)

Ź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ą.

[System.CLSCompliant(false)]
public static sbyte ToSByte (ulong value);

Parametry

value

UInt64

64-bitowa liczba całkowita bez znaku, która ma być konwertowana.

Zwraca

SByte

Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.

Atrybuty

CLSCompliantAttribute

Wyjątki

OverflowException

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.

ToSByte(UInt32)

Ź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ą.

[System.CLSCompliant(false)]
public static sbyte ToSByte (uint value);

Parametry

value

UInt32

32-bitowa liczba całkowita bez znaku, która ma być konwertowana.

Zwraca

SByte

Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.

Atrybuty

CLSCompliantAttribute

Wyjątki

OverflowException

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.

ToSByte(String)

Ź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.

[System.CLSCompliant(false)]
public static sbyte ToSByte (string? value);

Parametry

value

String

Ciąg zawierający liczbę, którą należy przekształcić.

Zwraca

SByte

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

CLSCompliantAttribute

Wyjątki

FormatException

value nie składa się z opcjonalnego znaku, po którym następuje sekwencja cyfr (od 0 do 9).

OverflowException

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 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
*/

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ż

• Parse(String)

ToSByte(Single)

Ź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.

[System.CLSCompliant(false)]
public static sbyte ToSByte (float value);

Parametry

value

Single

Liczba zmiennoprzecinkowa pojedynczej precyzji, która ma zostać przekształcona.

Zwraca

SByte

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

CLSCompliantAttribute

Wyjątki

OverflowException

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.

Zobacz też

• Single
• Round

ToSByte(Object)

Ź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.

[System.CLSCompliant(false)]
public static sbyte ToSByte (object? value);

Parametry

value

Object

Obiekt, który implementuje IConvertible interfejs lub null.

Zwraca

SByte

Liczba całkowita z podpisem 8-bitowym, która jest równoważna valuewartościom , lub zero, jeśli value jest to null.

Atrybuty

CLSCompliantAttribute

Wyjątki

FormatException

value nie jest w odpowiednim formacie.

InvalidCastException

value nie implementuje interfejsu IConvertible .

-lub-

Konwersja nie jest obsługiwana.

OverflowException

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.

Uwagi

Wartość zwracana jest wynikiem wywołania IConvertible.ToSByte metody bazowego typu value.

ToSByte(UInt16)

Ź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ą.

[System.CLSCompliant(false)]
public static sbyte ToSByte (ushort value);

Parametry

value

UInt16

16-bitowa liczba całkowita bez znaku, która ma zostać przekształcona.

Zwraca

SByte

Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.

Atrybuty

CLSCompliantAttribute

Wyjątki

OverflowException

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.

ToSByte(Int32)

Ź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ą.

[System.CLSCompliant(false)]
public static sbyte ToSByte (int value);

Parametry

value

Int32

Liczba całkowita z podpisem 32-bitowym do przekonwertowania.

Zwraca

SByte

Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.

Atrybuty

CLSCompliantAttribute

Wyjątki

OverflowException

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.

ToSByte(Int64)

Ź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ą.

[System.CLSCompliant(false)]
public static sbyte ToSByte (long value);

Parametry

value

Int64

Liczba całkowita z podpisem 64-bitowym do przekonwertowania.

Zwraca

SByte

Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.

Atrybuty

CLSCompliantAttribute

Wyjątki

OverflowException

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.

ToSByte(Byte)

Ź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ą.

[System.CLSCompliant(false)]
public static sbyte ToSByte (byte value);

Parametry

value

Byte

8-bitowa liczba całkowita bez znaku, która ma być konwertowana.

Zwraca

SByte

Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.

Atrybuty

CLSCompliantAttribute

Wyjątki

OverflowException

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.

ToSByte(Char)

Ź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.

[System.CLSCompliant(false)]
public static sbyte ToSByte (char value);

Parametry

value

Char

Znak Unicode, który ma zostać przekształcony.

Zwraca

SByte

Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.

Atrybuty

CLSCompliantAttribute

Wyjątki

OverflowException

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.

ToSByte(DateTime)

Ź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.

[System.CLSCompliant(false)]
public static sbyte ToSByte (DateTime value);

Parametry

value

DateTime

Wartość daty i godziny, która ma zostać przekształcona.

Zwraca

SByte

Ta konwersja nie jest obsługiwana. Nie jest zwracana żadna wartość.

Atrybuty

CLSCompliantAttribute

Wyjątki

InvalidCastException

Ta konwersja nie jest obsługiwana.

ToSByte(Boolean)

Ź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.

[System.CLSCompliant(false)]
public static sbyte ToSByte (bool value);

Parametry

value

Boolean

Wartość logiczna, która ma zostać przekształcona.

Zwraca

SByte

Liczba 1, jeśli value to true; w przeciwnym razie, 0.

Atrybuty

CLSCompliantAttribute

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.

ToSByte(Double)

Ź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.

[System.CLSCompliant(false)]
public static sbyte ToSByte (double value);

Parametry

value

Double

Liczba zmiennoprzecinkowa podwójnej precyzji, która ma zostać przekształcona.

Zwraca

SByte

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

CLSCompliantAttribute

Wyjątki

OverflowException

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.

Zobacz też

• Double
• Round

ToSByte(Int16)

Ź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ą.

[System.CLSCompliant(false)]
public static sbyte ToSByte (short value);

Parametry

value

Int16

16-bitowa liczba całkowita ze znakiem, która ma zostać przekształcona.

Zwraca

SByte

Liczba całkowita z podpisem 8-bitowym, która jest równoważna value.

Atrybuty

CLSCompliantAttribute

Wyjątki

OverflowException

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.

ToSByte(Decimal)

Ź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.

[System.CLSCompliant(false)]
public static sbyte ToSByte (decimal value);

Parametry

value

Decimal

Liczba dziesiętna, która ma zostać przekształcona.

Zwraca

SByte

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

CLSCompliantAttribute

Wyjątki

OverflowException

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.

Zobacz też

• Round