Convert.ToSByte Yöntem

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kod:

System.Runtime.dll

Belirtilen değeri 8 bit imzalı tamsayıya dönüştürür.

Aşırı Yüklemeler

ToSByte(SByte)	Belirtilen 8 bit imzalı tamsayıyı döndürür; gerçek dönüştürme gerçekleştirilmemesi.
ToSByte(String, Int32)	Belirtilen tabandaki bir sayının dize gösterimini eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.
ToSByte(String, IFormatProvider)	Bir sayının belirtilen dize gösterimini, belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.
ToSByte(Object, IFormatProvider)	Belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak belirtilen nesnenin değerini 8 bit imzalı tamsayıya dönüştürür.
ToSByte(UInt64)	Belirtilen 64 bit işaretsiz tamsayı değerini eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.
ToSByte(UInt32)	Belirtilen 32 bit işaretsiz tamsayı değerini eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.
ToSByte(String)	Bir sayının belirtilen dize gösterimini eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.
ToSByte(Single)	Belirtilen tek duyarlıklı kayan nokta sayısının değerini eşdeğer bir 8 bit işaretli tamsayıya dönüştürür.
ToSByte(Object)	Belirtilen nesnenin değerini 8 bit imzalı tamsayıya dönüştürür.
ToSByte(UInt16)	Belirtilen 16 bit işaretsiz tamsayı değerini eşdeğer 8 bit imzalı tamsayıya dönüştürür.
ToSByte(Int32)	Belirtilen 32 bit imzalı tamsayı değerini eşdeğer bir 8 bit işaretli tamsayıya dönüştürür.
ToSByte(Int64)	Belirtilen 64 bit imzalı tamsayı değerini eşdeğer bir 8 bit işaretli tamsayıya dönüştürür.
ToSByte(Byte)	Belirtilen 8 bit işaretsiz tamsayı değerini eşdeğer 8 bit imzalı tamsayıya dönüştürür.
ToSByte(Char)	Belirtilen Unicode karakterinin değerini eşdeğer 8 bit imzalı tamsayıya dönüştürür.
ToSByte(DateTime)	Bu yöntemin çağrılması her zaman InvalidCastExceptionoluşturur.
ToSByte(Boolean)	Belirtilen Boole değerini eşdeğer 8 bit imzalı tamsayıya dönüştürür.
ToSByte(Double)	Belirtilen çift duyarlıklı kayan nokta sayısının değerini eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.
ToSByte(Int16)	Belirtilen 16 bit imzalı tamsayı değerini eşdeğer 8 bit imzalı tamsayıya dönüştürür.
ToSByte(Decimal)	Belirtilen ondalık sayının değerini eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.

ToSByte(SByte)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen 8 bit imzalı tamsayıyı döndürür; gerçek dönüştürme gerçekleştirilmemesi.

C#

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

Parametreler

value

SByte

Döndürülecek 8 bit imzalı tamsayı.

Döndürülenler

SByte

value değiştirilmeden döndürülür.

Öznitelikler

CLSCompliantAttribute

ToSByte(String, Int32)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen tabandaki bir sayının dize gösterimini eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

String

Dönüştürülecek sayıyı içeren dize.

fromBase

Int32

valueiçinde 2, 8, 10 veya 16 olması gereken sayının tabanı.

Döndürülenler

SByte

valueiçindeki sayıya eşdeğer 8 bit işaretli tamsayı veya valuenullise 0 (sıfır) olur.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

ArgumentException

fromBase 2, 8, 10 veya 16 değildir.

-veya-

temel olmayan 10 imzalı bir sayıyı temsil eden value, önüne negatif bir işaret eklenir.

ArgumentOutOfRangeException

value Empty.

FormatException

value, fromBasetarafından belirtilen tabanda geçerli bir basamak olmayan bir karakter içerir. Özel durum iletisi, value'daki ilk karakter geçersizse dönüştürülecek basamak olmadığını gösterir; aksi takdirde, ileti value geçersiz sondaki karakterler içerdiğini gösterir.

OverflowException

temel olmayan 10 imzalı bir sayıyı temsil eden value, önüne negatif bir işaret eklenir.

-veya-

value, SByte.MinValue'den küçük veya SByte.MaxValue'den büyük bir sayıyı temsil eder.

Örnekler

Aşağıdaki örnek, bir dize dizisindeki öğeleri imzasız baytlara dönüştürmek için sayısal değerlerin ikili, sekizli ve onaltılık gösterimi olarak yorumlamaya çalışır.

C#

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

Açıklamalar

fromBase 16 ise, value parametresi tarafından belirtilen sayıya "0x" veya "0X" ön eki ekleyebilirsiniz.

Negatif işareti temel olmayan 10 sayısal gösterimler için desteklenmediğinden, ToSByte(String, Int32) yöntemi negatif sayıların ikinin tamamlayıcı gösterimini kullandığını varsayar. Başka bir deyişle, yöntemi her zaman bir baytın yüksek sıralı bitini (bit 7) işaret biti olarak yorumlar. Sonuç olarak, yöntem özel durum oluşturmadan SByte veri türü aralığının dışında olan 10 tabanı olmayan bir sayının SByte değerine dönüştürüldüğü kod yazmak mümkündür. Aşağıdaki örnek, MaxValue onaltılık dize gösterimine dönüştürür ve ToSByte(String, Int32) yöntemini çağırır. Yöntem bir özel durum atmak yerine "0xff -1'e dönüştürür" iletisini görüntüler.

C#

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

İkili işlemleri veya sayısal dönüştürmeleri gerçekleştirirken, bir yöntemin belirli bir değeri yorumlamak için uygun sayısal gösterimi kullandığını doğrulamak her zaman geliştiricinin sorumluluğundadır. Aşağıdaki örnekte gösterildiği gibi, bir değerin onaltılık dize gösterimine dönüştürürken önce imzasız veya imzalı bir türü temsil edip etmediğini belirleyerek yöntemin taşma işlemlerini uygun şekilde işlediğinden emin olabilirsiniz. Özgün değer imzasız bir türse, ancak imzalı bayta geri dönüştürme işlemi, işaret biti açık olan bir değer döndürdüyse bir özel durum oluşturur.

C#

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

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Bir sayının belirtilen dize gösterimini, belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

String

Dönüştürülecek sayıyı içeren dize.

provider

IFormatProvider

Kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

Döndürülenler

SByte

valueeşdeğer 8 bit imzalı tamsayı.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

ArgumentNullException

value null.

FormatException

value, isteğe bağlı bir işaretten ve ardından bir basamak dizisi (0 ile 9) arasında bir diziden oluşmaz.

OverflowException

value, SByte.MinValue'den küçük veya SByte.MaxValue'den büyük bir sayıyı temsil eder.

Örnekler

Aşağıdaki örnek, bir IFormatProvider nesnesi kullanarak ToSByte yöntemiyle SByte değerlerin dize gösterimlerini dönüştürür.

C#

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

Açıklamalar

provider, NumberFormatInfo nesnesi edinen IFormatProvider bir örnektir. NumberFormatInfo nesnesi, valuebiçimi hakkında kültüre özgü bilgiler sağlar. provider nullise, geçerli kültürün NumberFormatInfo kullanılır.

Dönüştürme başarısız olursa bir özel durumu işlemeyi tercih ederseniz, bunun yerine SByte.TryParse yöntemini çağırabilirsiniz. Dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösteren bir Boolean değeri döndürür.

Ayrıca bkz.

• Parse(String)

ToSByte(Object, IFormatProvider)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak belirtilen nesnenin değerini 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

Object

IConvertible arabirimini uygulayan bir nesne.

provider

IFormatProvider

Kültüre özgü biçimlendirme bilgileri sağlayan bir nesne.

Döndürülenler

SByte

valueeşdeğer bir 8 bit işaretli tamsayı veya valuenullise sıfır.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

FormatException

value uygun bir biçimde değil.

InvalidCastException

value IConvertible arabirimini uygulamaz.

-veya-

Dönüştürme desteklenmiyor.

OverflowException

value, SByte.MinValue'den küçük veya SByte.MaxValue'den büyük bir sayıyı temsil eder.

Örnekler

Aşağıdaki örnek, hem imzalı hem de imzasız baytları onaltılık dizeler olarak depolayan bir ByteString sınıfını ve bayt işaretini gösteren bir alanı tanımlar. ByteString sınıfı IConvertible arabirimini uygular. IConvertible.ToSByte yöntemi, dönüştürmeyi gerçekleştirmek için Parse(String, IFormatProvider) yöntemini çağırır. Başarısız olursa, bir OverflowExceptionoluşturur.

C#

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

Aşağıdaki örnekte, ByteString sınıfının IConvertible.ToSByte uygulamasının Convert.ToSByte(Object, IFormatProvider) yöntemi tarafından nasıl çağrıldığı gösterilmektedir.

C#

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.

Açıklamalar

provider, kullanıcının valueiçeriği hakkında kültüre özgü dönüştürme bilgilerini belirtmesini sağlar. Örneğin, value bir sayıyı temsil eden bir String ise, provider bu sayıyı temsil etmek için kullanılan gösterimi hakkında kültüre özgü bilgiler sağlayabilir.

Temel türler provideryoksayar; ancak, valueIConvertible arabirimini uygulayan kullanıcı tanımlı bir türse parametresi kullanılabilir.

ToSByte(UInt64)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen 64 bit işaretsiz tamsayı değerini eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

UInt64

Dönüştürülecek 64 bit işaretsiz tamsayı.

Döndürülenler

SByte

valueeşdeğer 8 bit imzalı tamsayı.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

OverflowException

value SByte.MaxValue büyüktür veya SByte.MinValuedeğerinden küçüktür.

Örnekler

Aşağıdaki örnek, uzun tamsayılar dizisindeki her öğeyi imzalı bayta dönüştürmeyi dener.

C#

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)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen 32 bit işaretsiz tamsayı değerini eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

UInt32

Dönüştürülecek 32 bit işaretsiz tamsayı.

Döndürülenler

SByte

valueeşdeğer 8 bit imzalı tamsayı.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

OverflowException

value SByte.MaxValue büyüktür veya SByte.MinValuedeğerinden küçüktür.

Örnekler

Aşağıdaki örnek, bir tamsayı dizisindeki her öğeyi imzalı bayta dönüştürmeyi dener.

C#

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)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Bir sayının belirtilen dize gösterimini eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

String

Dönüştürülecek sayıyı içeren dize.

Döndürülenler

SByte

valueiçindeki sayıya eşdeğer 8 bit işaretli tamsayı veya değer nullise 0 (sıfır) olur.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

FormatException

value, isteğe bağlı bir işaretten ve ardından bir basamak dizisi (0 ile 9) arasında bir diziden oluşmaz.

OverflowException

value, SByte.MinValue'den küçük veya SByte.MaxValue'den büyük bir sayıyı temsil eder.

Örnekler

Aşağıdaki örnek, varsayılan biçimlendirmeyi kullanarak SByte değerlerin dize gösterimlerini ToSByte yöntemiyle dönüştürür.

C#

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

Açıklamalar

ToSByte(String) yönteminin kullanılması, valueSByte.Parse(String) yöntemine geçirmekle eşdeğerdir. value, geçerli kültürün biçimlendirme kuralları kullanılarak yorumlanır.

Dönüştürme başarısız olursa bir özel durumu işlemeyi tercih ederseniz, bunun yerine SByte.TryParse yöntemini çağırabilirsiniz. Dönüştürmenin başarılı mı yoksa başarısız mı olduğunu gösteren bir Boolean değeri döndürür.

Ayrıca bkz.

• Parse(String)

ToSByte(Single)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen tek duyarlıklı kayan nokta sayısının değerini eşdeğer bir 8 bit işaretli tamsayıya dönüştürür.

C#

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

Parametreler

value

Single

Dönüştürülecek tek duyarlıklı kayan nokta sayısı.

Döndürülenler

SByte

value, en yakın 8 bit işaretli tamsayıya yuvarlanmış. value iki tamsayı arasındaysa çift sayı döndürülür; yani, 4,5 4'e, 5,5 ise 6'ya dönüştürülür.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

OverflowException

value SByte.MaxValue büyüktür veya SByte.MinValuedeğerinden küçüktür.

Örnekler

Aşağıdaki örnek, Single değerleri dizisindeki her öğeyi imzalı bayta dönüştürmeyi dener.

C#

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.

Ayrıca bkz.

• Single
• Round

ToSByte(Object)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen nesnenin değerini 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

Object

IConvertible arabirimini uygulayan bir nesne veya null.

Döndürülenler

SByte

valueeşdeğer bir 8 bit işaretli tamsayı veya valuenullise sıfır.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

FormatException

value uygun bir biçimde değil.

InvalidCastException

value IConvertible arabirimini uygulamaz.

-veya-

Dönüştürme desteklenmiyor.

OverflowException

value, SByte.MinValue'den küçük veya SByte.MaxValue'den büyük bir sayıyı temsil eder.

Örnekler

Aşağıdaki örnek, bir nesne dizisindeki her öğeyi imzalı bayta dönüştürmeyi dener.

C#

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.

Açıklamalar

Dönüş değeri, temel alınan valuetürünün IConvertible.ToSByte yöntemini çağırmanın sonucudur.

ToSByte(UInt16)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen 16 bit işaretsiz tamsayı değerini eşdeğer 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

UInt16

Dönüştürülecek 16 bit işaretsiz tamsayı.

Döndürülenler

SByte

valueeşdeğer 8 bit imzalı tamsayı.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

OverflowException

value SByte.MaxValuedeğerinden büyüktür.

Örnekler

Aşağıdaki örnek, imzalanmamış 16 bit tamsayı dizisindeki her öğeyi imzalı bayta dönüştürmeyi dener.

C#

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)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen 32 bit imzalı tamsayı değerini eşdeğer bir 8 bit işaretli tamsayıya dönüştürür.

C#

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

Parametreler

value

Int32

Dönüştürülecek 32 bit imzalı tamsayı.

Döndürülenler

SByte

valueeşdeğer 8 bit imzalı tamsayı.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

OverflowException

value SByte.MaxValue büyüktür veya SByte.MinValuedeğerinden küçüktür.

Örnekler

Aşağıdaki örnek, imzalı tamsayılar dizisindeki her öğeyi imzalı bayta dönüştürmeyi dener.

C#

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)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen 64 bit imzalı tamsayı değerini eşdeğer bir 8 bit işaretli tamsayıya dönüştürür.

C#

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

Parametreler

value

Int64

Dönüştürülecek 64 bit imzalı tamsayı.

Döndürülenler

SByte

valueeşdeğer 8 bit imzalı tamsayı.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

OverflowException

value SByte.MaxValue büyüktür veya SByte.MinValuedeğerinden küçüktür.

Örnekler

Aşağıdaki örnek, uzun tamsayılar dizisindeki her öğeyi imzalı bayta dönüştürmeyi dener.

C#

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)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen 8 bit işaretsiz tamsayı değerini eşdeğer 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

Byte

Dönüştürülecek 8 bit işaretsiz tamsayı.

Döndürülenler

SByte

valueeşdeğer 8 bit imzalı tamsayı.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

OverflowException

value SByte.MaxValuedeğerinden büyüktür.

Örnekler

Aşağıdaki örnek, bayt dizisindeki her öğeyi imzalı bir bayta dönüştürmeyi dener.

C#

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)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen Unicode karakterinin değerini eşdeğer 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

Char

Dönüştürülecek Unicode karakteri.

Döndürülenler

SByte

valueeşdeğer 8 bit imzalı tamsayı.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

OverflowException

value SByte.MaxValuedeğerinden büyüktür.

Örnekler

Aşağıdaki örnek, Char değerleri dizisindeki her öğeyi imzalı bayta dönüştürmeyi dener.

C#

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)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Bu yöntemin çağrılması her zaman InvalidCastExceptionoluşturur.

C#

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

Parametreler

value

DateTime

Dönüştürülecek tarih ve saat değeri.

Döndürülenler

SByte

Bu dönüştürme desteklenmez. Değer döndürülmedi.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

InvalidCastException

Bu dönüştürme desteklenmez.

ToSByte(Boolean)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen Boole değerini eşdeğer 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

Boolean

Dönüştürülecek Boole değeri.

Döndürülenler

SByte

value trueise 1 sayısı; aksi takdirde, 0.

Öznitelikler

CLSCompliantAttribute

Örnekler

Aşağıdaki örnek true ve false Boole değerlerini imzalı bayt değerlerine dönüştürür.

C#

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)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen çift duyarlıklı kayan nokta sayısının değerini eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

Double

Dönüştürülecek çift duyarlıklı kayan nokta sayısı.

Döndürülenler

SByte

value, en yakın 8 bit işaretli tamsayıya yuvarlanmış. value iki tamsayı arasındaysa çift sayı döndürülür; yani, 4,5 4'e, 5,5 ise 6'ya dönüştürülür.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

OverflowException

value SByte.MaxValue büyüktür veya SByte.MinValuedeğerinden küçüktür.

Örnekler

Aşağıdaki örnek, Double değerleri dizisindeki her öğeyi imzalı bayta dönüştürmeyi dener.

C#

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.

Ayrıca bkz.

• Double
• Round

ToSByte(Int16)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen 16 bit imzalı tamsayı değerini eşdeğer 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

Int16

Dönüştürülecek 16 bit imzalı tamsayı.

Döndürülenler

SByte

valueeşdeğer 8 bit imzalı tamsayı.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

OverflowException

value SByte.MaxValue büyüktür veya SByte.MinValuedeğerinden küçüktür.

Örnekler

Aşağıdaki örnek, imzalı 16 bitlik tamsayı dizisindeki her öğeyi imzalı bayta dönüştürmeyi dener.

C#

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)

Kaynak:

Convert.cs

Önemli

Bu API, CLS uyumlu değildir.

Belirtilen ondalık sayının değerini eşdeğer bir 8 bit imzalı tamsayıya dönüştürür.

C#

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

Parametreler

value

Decimal

Dönüştürülecek ondalık sayı.

Döndürülenler

SByte

value, en yakın 8 bit işaretli tamsayıya yuvarlanmış. value iki tamsayı arasındaysa çift sayı döndürülür; yani, 4,5 4'e, 5,5 ise 6'ya dönüştürülür.

Öznitelikler

CLSCompliantAttribute

Özel durumlar

OverflowException

value SByte.MaxValue büyüktür veya SByte.MinValuedeğerinden küçüktür.

Örnekler

Aşağıdaki örnek, Decimal değerleri dizisindeki her öğeyi imzalı bayta dönüştürmeyi dener.

C#

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.

Ayrıca bkz.

• Round