Single Yapı

Tanım

Tek duyarlıklı kayan noktalı sayıyı temsil eder.Represents a single-precision floating-point number.

public value class Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
public value class Single : IComparable, IConvertible, IFormattable
public value class Single : IComparable, IComparable<float>, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
[System.Serializable]
public struct Single : IComparable, IConvertible, IFormattable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
public struct Single : IComparable, IComparable<float>, IEquatable<float>, IFormattable
type single = struct
    interface IConvertible
    interface IFormattable
type single = struct
    interface IFormattable
    interface IConvertible
type single = struct
    interface IFormattable
Public Structure Single
Implements IComparable, IComparable(Of Single), IConvertible, IEquatable(Of Single), IFormattable
Public Structure Single
Implements IComparable, IConvertible, IFormattable
Public Structure Single
Implements IComparable, IComparable(Of Single), IEquatable(Of Single), IFormattable
Devralma
Single
Öznitelikler
Uygulamalar

Açıklamalar

Single değer türü, negatif 3.402823 E38 'den pozitif 3.402823 E38 ve pozitif veya negatif sıfır, PositiveInfinity, NegativeInfinityve sayı değil (NaN) arasında değişen değerler içeren tek duyarlıklı 32 bitlik bir sayıyı temsil eder.The Single value type represents a single-precision 32-bit number with values ranging from negative 3.402823e38 to positive 3.402823e38, as well as positive or negative zero, PositiveInfinity, NegativeInfinity, and not a number (NaN). Son derece büyük (örneğin, planorlar veya galakileri) veya son derece küçük (örneğin, dünya çapında başka bir Solar sistemine olan uzaklık gibi) değerleri temsil etmek için tasarlanmıştır. ).It is intended to represent values that are extremely large (such as distances between planets or galaxies) or extremely small (such as the molecular mass of a substance in kilograms) and that often are imprecise (such as the distance from earth to another solar system). Single türü, ikili kayan nokta aritmetiği için ıEC 60559:1989 (IEEE 754) standardına uyar.The Single type complies with the IEC 60559:1989 (IEEE 754) standard for binary floating-point arithmetic.

Bu konu aşağıdaki bölümlerden oluşur:This topic consists of the following sections:

System.Single, bu türdeki örnekleri karşılaştırmak, bir örneğin değerini dize gösterimine dönüştürmek ve bir sayının dize gösterimini bu türün bir örneğine dönüştürmek için yöntemler sağlar.System.Single provides methods to compare instances of this type, to convert the value of an instance to its string representation, and to convert the string representation of a number to an instance of this type. Biçim belirtim kodlarının, değer türlerinin dize gösterimini nasıl denetdiği hakkında bilgi için bkz. biçimlendirme türleri, Standart sayısal biçim dizelerive özel sayısal biçim dizeleri.For information about how format specification codes control the string representation of value types, see Formatting Types, Standard Numeric Format Strings, and Custom Numeric Format Strings.

Kayan nokta gösterimi ve duyarlıkFloating-point representation and precision

Single veri türü, aşağıdaki tabloda gösterildiği gibi tek duyarlıklı kayan nokta değerlerini 32 bitlik ikili biçimde depolar:The Single data type stores single-precision floating-point values in a 32-bit binary format, as shown in the following table:

BölümüylePart BitsBits
Mantisinin veya MantisSignificand or mantissa 0-220-22
SExponent 23-3023-30
İmzala (0 = pozitif, 1 = negatif)Sign (0 = positive, 1 = negative) 3131

Ondalık kesirler, bazı kesirli değerleri (örneğin, 1/3 veya Math.PI) tam olarak temsil etmediği gibi, ikili kesirler bazı kesirli değerleri temsil etmez.Just as decimal fractions are unable to precisely represent some fractional values (such as 1/3 or Math.PI), binary fractions are unable to represent some fractional values. Örneğin, bir ondalık kesir olarak .2 tarafından tam olarak temsil edilen 2/10, "1100" adlı bir "" düzeniyle sonsuz bir kesir olarak. 0011111001001100 tarafından temsil edilir.For example, 2/10, which is represented precisely by .2 as a decimal fraction, is represented by .0011111001001100 as a binary fraction, with the pattern "1100" repeating to infinity. Bu durumda, kayan nokta değeri, temsil ettiği sayının kesin bir gösterimini sağlar.In this case, the floating-point value provides an imprecise representation of the number that it represents. Özgün kayan nokta değeri üzerinde ek matematik işlemleri gerçekleştirmek genellikle duyarlık olmaması durumunda artar.Performing additional mathematical operations on the original floating-point value often increases its lack of precision. Örneğin, .3 'in çarpılmasıyla elde edilen sonuçları 10 olarak karşılaştırırsanız ve .3.3 9 kez eklerseniz, bu ek daha az kesin sonuç ürettiğini görürsünüz çünkü çarpmadan daha fazla işlem içeriyor.For example, if you compare the results of multiplying .3 by 10 and adding .3 to .3 nine times, you will see that addition produces the less precise result, because it involves eight more operations than multiplication. Bu ayırmanın yalnızca, "R" Standart sayısal biçim dizesikullanarak, gerekirse, Single türü tarafından desteklenen tüm 9 basamak değerlerini görüntülemesi Single durumunda görünür olduğunu unutmayın.Note that this disparity is apparent only if you display the two Single values by using the "R" standard numeric format string, which, if necessary, displays all 9 digits of precision supported by the Single type.

using System;

public class Example
{
   public static void Main()
   {
      Single value = .2f;
      Single result1 = value * 10f;
      Single result2 = 0f;
      for (int ctr = 1; ctr <= 10; ctr++)
         result2 += value;

      Console.WriteLine(".2 * 10:           {0:R}", result1);
      Console.WriteLine(".2 Added 10 times: {0:R}", result2);
   }
}
// The example displays the following output:
//       .2 * 10:           2
//       .2 Added 10 times: 2.00000024
Module Example
   Public Sub Main()
      Dim value As Single = .2
      Dim result1 As Single = value * 10
      Dim result2 As Single
      For ctr As Integer = 1 To 10
         result2 += value
      Next
      Console.WriteLine(".2 * 10:           {0:R}", result1)
      Console.WriteLine(".2 Added 10 times: {0:R}", result2)
   End Sub
End Module
' The example displays the following output:
'       .2 * 10:           2
'       .2 Added 10 times: 2.00000024

Bazı sayılar tam olarak kesirli ikili değerler olarak temsil edilemediğinden, kayan noktalı sayılar yalnızca gerçek sayıları tahmin edebilir.Because some numbers cannot be represented exactly as fractional binary values, floating-point numbers can only approximate real numbers.

Tüm kayan nokta sayıları sınırlı sayıda önemli basamağa sahiptir ve bu da bir kayan nokta değerinin gerçek bir sayıyı ne kadar doğru bir şekilde değiştireceğini belirler.All floating-point numbers have a limited number of significant digits, which also determines how accurately a floating-point value approximates a real number. Bir Single değeri en fazla 7 ondalık basamak duyarlığa sahiptir, ancak dahili olarak en fazla 9 basamak saklanır.A Single value has up to 7 decimal digits of precision, although a maximum of 9 digits is maintained internally. Yani, bazı kayan nokta işlemlerinde bir kayan nokta değerini değiştirmek için duyarlık yetersiz olabilir.This means that some floating-point operations may lack the precision to change a floating-point value. Aşağıdaki örnek, büyük bir tek duyarlıklı kayan noktalı değeri tanımlar ve ardından Single.Epsilon ve bir quadrillion ürününü buna ekler.The following example defines a large single-precision floating-point value, and then adds the product of Single.Epsilon and one quadrillion to it. Ancak, ürün orijinal kayan nokta değerini değiştirmek için çok küçük.However, the product is too small to modify the original floating-point value. En az önemli basamak binde, ancak üründeki en önemli basamak 10-30' dur.Its least significant digit is thousandths, whereas the most significant digit in the product is 10-30.

using System;

public class Example
{
   public static void Main()
   {
      Single value = 123.456f;
      Single additional = Single.Epsilon * 1e15f;
      Console.WriteLine($"{value} + {additional} = {value + additional}");
   }
}
// The example displays the following output:
//    123.456 + 1.401298E-30 = 123.456
Module Example
   Public Sub Main()
      Dim value As Single = 123.456
      Dim additional As Single = Single.Epsilon * 1e15
      Console.WriteLine($"{value} + {additional} = {value + additional}")
   End Sub
End Module
' The example displays the following output:
'   123.456 + 1.401298E-30 = 123.456

Kayan noktalı sayının sınırlı duyarlığı birkaç sonuçlara sahiptir:The limited precision of a floating-point number has several consequences:

  • Belirli bir duyarlık için eşit olarak görünen iki kayan nokta numarası, en az önemli basamaklar farklı olduğu için eşit olarak karşılaştırmayabilir.Two floating-point numbers that appear equal for a particular precision might not compare equal because their least significant digits are different. Aşağıdaki örnekte, bir dizi sayı birlikte eklenir ve toplamı beklenen toplam ile karşılaştırılır.In the following example, a series of numbers are added together, and their total is compared with their expected total. İki değer aynı gibi görünse de, Equals yöntemine yapılan bir çağrı olmadığını gösterir.Although the two values appear to be the same, a call to the Equals method indicates that they are not.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Single[] values = { 10.01f, 2.88f, 2.88f, 2.88f, 9.0f };
          Single result = 27.65f;
          Single total = 0f;
          foreach (var value in values)
             total += value;
    
          if (total.Equals(result))
             Console.WriteLine("The sum of the values equals the total.");
          else
             Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                               total, result); 
       }
    }
    // The example displays the following output:
    //      The sum of the values (27.65) does not equal the total (27.65).   
    //
    // If the index items in the Console.WriteLine statement are changed to {0:R},
    // the example displays the following output:
    //       The sum of the values (27.6500015) does not equal the total (27.65).   
    
    Module Example
       Public Sub Main()
          Dim values() As Single = { 10.01, 2.88, 2.88, 2.88, 9.0 }
          Dim result As Single = 27.65
          Dim total As Single
          For Each value In values
             total += value
          Next
          If total.Equals(result) Then
             Console.WriteLine("The sum of the values equals the total.")
          Else
             Console.WriteLine("The sum of the values ({0}) does not equal the total ({1}).",
                               total, result) 
          End If     
       End Sub
    End Module
    ' The example displays the following output:
    '      The sum of the values (27.65) does not equal the total (27.65).   
    '
    ' If the index items in the Console.WriteLine statement are changed to {0:R},
    ' the example displays the following output:
    '       The sum of the values (27.639999999999997) does not equal the total (27.64).   
    

    Console.WriteLine(String, Object, Object) deyimindeki biçim öğelerini {0} ve {0:R} {1} ve {1:R} iki Single değerin tüm önemli basamaklarını görüntüleyecek şekilde değiştirirseniz, toplama işlemleri sırasında duyarlık kaybı nedeniyle iki değerin eşit olduğundan net değildir.If you change the format items in the Console.WriteLine(String, Object, Object) statement from {0} and {1} to {0:R} and {1:R} to display all significant digits of the two Single values, it is clear that the two values are unequal because of a loss of precision during the addition operations. Bu durumda, sorun, karşılaştırmayı gerçekleştirmeden önce Single değerlerini istenen duyarlığa yuvarlamak için Math.Round(Double, Int32) yöntemi çağırarak çözülebilir.In this case, the issue can be resolved by calling the Math.Round(Double, Int32) method to round the Single values to the desired precision before performing the comparison.

  • Kayan noktalı sayı kullanan matematik veya karşılaştırma işlemi, bir ondalık sayı kullanılırsa, ikili kayan noktalı sayı ondalık sayıya eşit olmadığı için aynı sonucu ortaya çıkabilir.A mathematical or comparison operation that uses a floating-point number might not yield the same result if a decimal number is used, because the binary floating-point number might not equal the decimal number. Önceki bir örnek bunu, .3 ile çarpılacak ve .3.3 9 kez ekleyen sonucu görüntüleyerek gösteriliyor.A previous example illustrated this by displaying the result of multiplying .3 by 10 and adding .3 to .3 nine times.

    Kesirli değerlere sahip sayısal işlemlerdeki doğruluk önemli olduğunda, Single türü yerine Decimal türünü kullanın.When accuracy in numeric operations with fractional values is important, use the Decimal type instead of the Single type. Int64 veya UInt64 türlerinin ötesinde tamsayı değerleri olan sayısal işlemlerdeki doğruluk önemli olduğunda BigInteger türünü kullanın.When accuracy in numeric operations with integral values beyond the range of the Int64 or UInt64 types is important, use the BigInteger type.

  • Bir kayan noktalı sayı varsa bir değer gidiş dönüş olmayabilir.A value might not round-trip if a floating-point number is involved. Bir işlem özgün kayan nokta sayısını başka bir forma dönüştürdüğünde, bir değer gidiş dönüş olarak kabul edilir, ters işlem dönüştürülen formu bir kayan noktalı sayıya geri dönüştürür ve son kayan nokta numarası orijinale eşittir kayan noktalı sayı.A value is said to round-trip if an operation converts an original floating-point number to another form, an inverse operation transforms the converted form back to a floating-point number, and the final floating-point number is equal to the original floating-point number. Bir dönüşümde bir veya daha fazla en az önemli basamak kaybolduğu veya değiştiği için gidiş dönüş başarısız olabilir.The round trip might fail because one or more least significant digits are lost or changed in a conversion. Aşağıdaki örnekte, üç Single değeri dizelere dönüştürülür ve bir dosyaya kaydedilir.In the following example, three Single values are converted to strings and saved in a file. Çıktıda gösterildiği gibi, değerler aynı gibi görünse de, geri yüklenen değerler özgün değerlere eşit değildir.As the output shows, although the values appear to be identical, the restored values are not equal to the original values.

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) {
             sw.Write(values[ctr].ToString());
             if (ctr != values.Length - 1)
                sw.Write("|");
          }      
          sw.Close();
          
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Single.Parse(tempStrings[ctr]);   
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.882883 <> 2.882883
    //       0.3333333 <> 0.3333333
    //       3.141593 <> 3.141593
    
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\Singles.dat")
          Dim values() As Single = { 3.2/1.11, 1.0/3, CSng(Math.PI)  }
          For ctr As Integer = 0 To values.Length - 1
             sw.Write(values(ctr).ToString())
             If ctr <> values.Length - 1 Then sw.Write("|")
          Next      
          sw.Close()
          
          Dim restoredValues(values.Length - 1) As Single
          Dim sr As New StreamReader(".\Singles.dat")
          Dim temp As String = sr.ReadToEnd()
          Dim tempStrings() As String = temp.Split("|"c)
          For ctr As Integer = 0 To tempStrings.Length - 1
             restoredValues(ctr) = Single.Parse(tempStrings(ctr))   
          Next 
    
          For ctr As Integer = 0 To values.Length - 1
             Console.WriteLine("{0} {2} {1}", values(ctr), 
                               restoredValues(ctr),
                               If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '        2.882883 <> 2.882883
    '        0.3333333 <> 0.3333333
    '        3.141593 <> 3.141593
    

    Bu durumda, aşağıdaki örnekte gösterildiği gibi, Single değerlerinin tam hassasiyetini korumak için "G9" Standart sayısal biçim dizesi kullanılarak değerler başarıyla yuvarlayabilirsiniz.In this case, the values can be successfully round-tripped by using the "G9" standard numeric format string to preserve the full precision of Single values, as the following example shows.

    using System;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\Singles.dat");
          Single[] values = { 3.2f/1.11f, 1.0f/3f, (float) Math.PI };
          for (int ctr = 0; ctr < values.Length; ctr++) 
             sw.Write("{0:G9}{1}", values[ctr], ctr < values.Length - 1 ? "|" : "" );
          
          sw.Close();
          
          Single[] restoredValues = new Single[values.Length];
          StreamReader sr = new StreamReader(@".\Singles.dat");
          string temp = sr.ReadToEnd();
          string[] tempStrings = temp.Split('|');
          for (int ctr = 0; ctr < tempStrings.Length; ctr++)
             restoredValues[ctr] = Single.Parse(tempStrings[ctr]);   
    
          for (int ctr = 0; ctr < values.Length; ctr++)
             Console.WriteLine("{0} {2} {1}", values[ctr], 
                               restoredValues[ctr],
                               values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>");
       }
    }
    // The example displays the following output:
    //       2.882883 = 2.882883
    //       0.3333333 = 0.3333333
    //       3.141593 = 3.141593
    
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\Singles.dat")
          Dim values() As Single = { 3.2/1.11, 1.0/3, CSng(Math.PI)  }
          For ctr As Integer = 0 To values.Length - 1
             sw.Write("{0:G9}{1}", values(ctr), 
                      If(ctr < values.Length - 1, "|", ""))
          Next      
          sw.Close()
          
          Dim restoredValues(values.Length - 1) As Single
          Dim sr As New StreamReader(".\Singles.dat")
          Dim temp As String = sr.ReadToEnd()
          Dim tempStrings() As String = temp.Split("|"c)
          For ctr As Integer = 0 To tempStrings.Length - 1
             restoredValues(ctr) = Single.Parse(tempStrings(ctr))   
          Next 
    
          For ctr As Integer = 0 To values.Length - 1
             Console.WriteLine("{0} {2} {1}", values(ctr), 
                               restoredValues(ctr),
                               If(values(ctr).Equals(restoredValues(ctr)), "=", "<>"))
          Next
       End Sub
    End Module
    ' The example displays the following output:
    '       2.882883 = 2.882883
    '       0.3333333 = 0.3333333
    '       3.141593 = 3.141593
    
  • Single değerler Double değerden daha az duyarlığa sahiptir.Single values have less precision than Double values. Benzer bir eşdeğer Double dönüştürülmüş bir Single değeri, Duyarlığın farklılığı nedeniyle genellikle Double değerine eşit değildir.A Single value that is converted to a seemingly equivalent Double often does not equal the Double value because of differences in precision. Aşağıdaki örnekte, aynı bölme işlemlerinin sonucu Double bir değere ve bir Single değerine atanır.In the following example, the result of identical division operations is assigned to a Double value and a Single value. Single değeri bir Doubleaktardıktan sonra, iki değerin bir karşılaştırması eşit olduğunu gösterir.After the Single value is cast to a Double, a comparison of the two values shows that they are unequal.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1/3.0;
          Single sValue2 = 1/3.0f;
          Double value2 = (Double) sValue2;
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, 
                                              value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.33333333333333331 = 0.3333333432674408: False
    
    Module Example
       Public Sub Main()
          Dim value1 As Double = 1/3
          Dim sValue2 As Single = 1/3
          Dim value2 As Double = CDbl(sValue2)
          Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
       End Sub
    End Module
    ' The example displays the following output:
    '       0.33333333333333331 = 0.3333333432674408: False
    

    Bu sorundan kaçınmak için, Single veri türü yerine Double veri türünü kullanın ya da her iki değerin aynı duyarlığa sahip olması için Round metodunu kullanın.To avoid this problem, either use the Double data type in place of the Single data type, or use the Round method so that both values have the same precision.

Eşitlik sınamasıTesting for equality

Eşit kabul edilmesi için iki Single değeri özdeş değerleri temsil etmelidir.To be considered equal, two Single values must represent identical values. Bununla birlikte, değerler arasındaki duyarlık farklılığı veya bir ya da her iki değer tarafından bir duyarlık kaybı nedeniyle, aynı olması beklenen kayan nokta değerleri, en az önemli rakamlarla farklılığı nedeniyle eşit olmayan şekilde zaman aşımına uğrar.However, because of differences in precision between values, or because of a loss of precision by one or both values, floating-point values that are expected to be identical often turn out to be unequal due to differences in their least significant digits. Sonuç olarak, iki değerin eşit olup olmadığını ve iki Single değeri arasındaki ilişkiyi belirlemede CompareTo yöntemine çağrı yapıp, genellikle beklenmeyen sonuçlara neden olan Equals yöntemine çağrı yapın.As a result, calls to the Equals method to determine whether two values are equal, or calls to the CompareTo method to determine the relationship between two Single values, often yield unexpected results. Bu, ikinci değer 9 ' a sahip olduğu için, iki görünüşe eşit Single değerlerinin eşit olmadığı bir şekilde bir kez eşit olduğu için bu şekilde belirlenir.This is evident in the following example, where two apparently equal Single values turn out to be unequal, because the first value has 7 digits of precision, whereas the second value has 9.

using System;

public class Example
{
   public static void Main()
   {
      float value1 = .3333333f;
      float value2 = 1.0f/3;
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
   }
}
// The example displays the following output:
//        0.3333333 = 0.333333343: False
Module Example
   Public Sub Main()
      Dim value1 As Single = .3333333
      Dim value2 As Single = 1/3
      Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
   End Sub
End Module
' The example displays the following output:
'       0.3333333 = 0.333333343: False

Farklı kod yollarını izleyen ve farklı yollarla uygulanan Hesaplanmış değerler genellikle eşit olarak bir şekilde harcanacaktır.Calculated values that follow different code paths and that are manipulated in different ways often prove to be unequal. Aşağıdaki örnekte, bir Single değeri kare içinde olur ve sonra özgün değeri geri yüklemek için kare kök hesaplanır.In the following example, one Single value is squared, and then the square root is calculated to restore the original value. İkinci bir Single, başlangıçtaki değeri geri yüklemek için sonucun karekökünü 3,51 ayırarak 3,51 ve kare kök değerinin çarpılmasıyla hesaplanır.A second Single is multiplied by 3.51 and squared before the square root of the result is divided by 3.51 to restore the original value. İki değer özdeş gibi görünse de Equals(Single) yöntemine yapılan bir çağrı eşit olmadığını gösterir.Although the two values appear to be identical, a call to the Equals(Single) method indicates that they are not equal. Her bir Single değerinin tüm önemli basamaklarını görüntüleyen bir sonuç dizesi döndürmek için "G9" standart biçim dizesi kullanmak, ikinci değerin birinciden küçük .0000000000001 olduğunu gösterir.Using the "G9" standard format string to return a result string that displays all the significant digits of each Single value shows that the second value is .0000000000001 less than the first.

using System;

public class Example
{
   public static void Main()
   {
      float value1 = 10.201438f;
      value1 = (float) Math.Sqrt((float) Math.Pow(value1, 2));
      float value2 = (float) Math.Pow((float) value1 * 3.51f, 2);
      value2 = ((float) Math.Sqrt(value2)) / 3.51f;
      Console.WriteLine("{0} = {1}: {2}\n", 
                        value1, value2, value1.Equals(value2)); 
      Console.WriteLine("{0:G9} = {1:G9}", value1, value2); 
   }
}
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389
Module Example
   Public Sub Main()
      Dim value1 As Single = 10.201438
      value1 = CSng(Math.Sqrt(CSng(Math.Pow(value1, 2))))
      Dim value2 As Single = CSng(Math.Pow(value1 * CSng(3.51), 2))
      value2 = CSng(Math.Sqrt(value2) / CSng(3.51))
      Console.WriteLine("{0} = {1}: {2}", 
                        value1, value2, value1.Equals(value2)) 
      Console.WriteLine()
      Console.WriteLine("{0:G9} = {1:G9}", value1, value2) 
   End Sub
End Module
' The example displays the following output:
'       10.20144 = 10.20144: False
'       
'       10.201438 = 10.2014389

Duyarlık kaybını bir karşılaştırmanın sonucunu etkilemesinin olası olduğu durumlarda, Equals veya CompareTo yöntemini çağırmak yerine aşağıdaki teknikleri kullanabilirsiniz:In cases where a loss of precision is likely to affect the result of a comparison, you can use the following techniques instead of calling the Equals or CompareTo method:

  • Her iki değerin de aynı duyarlığa sahip olduğundan emin olmak için Math.Round yöntemini çağırın.Call the Math.Round method to ensure that both values have the same precision. Aşağıdaki örnek, iki kesirli değerin eşdeğer olması için bu yaklaşımı kullanmak üzere önceki bir örneği değiştirir.The following example modifies a previous example to use this approach so that two fractional values are equivalent.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = .3333333f;
          float value2 = 1.0f/3;
          int precision = 7;
          value1 = (float) Math.Round(value1, precision);
          value2 = (float) Math.Round(value2, precision);
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.3333333 = 0.3333333: True
    
    Module Example
       Public Sub Main()
          Dim value1 As Single = .3333333
          Dim value2 As Single = 1/3
          Dim precision As Integer = 7
          value1 = CSng(Math.Round(value1, precision))
          value2 = CSng(Math.Round(value2, precision))
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, value1.Equals(value2))
       End Sub
    End Module
    ' The example displays the following output:
    '       0.3333333 = 0.3333333: True
    

    Duyarlık sorununun, orta değer değerlerinin yuvarlanması için hala geçerli olduğunu unutmayın.Note that the problem of precision still applies to rounding of midpoint values. Daha fazla bilgi için bkz. Math.Round(Double, Int32, MidpointRounding) yöntemi.For more information, see the Math.Round(Double, Int32, MidpointRounding) method.

  • Eşitlik yerine yaklaşık eşitlik için test edin.Test for approximate equality instead of equality. Bu teknik, iki değerin farklı olmasına karşın eşit olmaya devam ettiği ya da daha küçük bir değerin daha büyük değerden ayırt edilebilen bir göreli miktarı tanımladığınız mutlak bir miktar tanımlamanızı gerektirir.This technique requires that you define either an absolute amount by which the two values can differ but still be equal, or that you define a relative amount by which the smaller value can diverge from the larger value.

    Uyarı

    Single.Epsilon bazen, eşitlik için test edilirken iki Single değeri arasındaki uzaklığın mutlak ölçüsü olarak kullanılır.Single.Epsilon is sometimes used as an absolute measure of the distance between two Single values when testing for equality. Ancak Single.Epsilon, değeri sıfır olan bir Single eklenebilen ya da çıkarılan olası en küçük değeri ölçer.However, Single.Epsilon measures the smallest possible value that can be added to, or subtracted from, a Single whose value is zero. En pozitif ve negatif Single değerleri için Single.Epsilon değeri algılanamayacak kadar küçük.For most positive and negative Single values, the value of Single.Epsilon is too small to be detected. Bu nedenle, sıfır olan değerler dışında, bir eşitlik için testlerin kullanımını önermiyoruz.Therefore, except for values that are zero, we do not recommend its use in tests for equality.

    Aşağıdaki örnek, iki değer arasındaki göreli farkı test eden bir IsApproximatelyEqual yöntemi tanımlamak için ikinci yaklaşımı kullanır.The following example uses the latter approach to define an IsApproximatelyEqual method that tests the relative difference between two values. Ayrıca, IsApproximatelyEqual metoduna ve Equals(Single) yöntemine yapılan çağrıların sonucunu da karşıtdır.It also contrasts the result of calls to the IsApproximatelyEqual method and the Equals(Single) method.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float one1 = .1f * 10;
          float one2 = 0f;
          for (int ctr = 1; ctr <= 10; ctr++)
             one2 += .1f;
    
          Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2));
          Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                            one1, one2, 
                            IsApproximatelyEqual(one1, one2, .000001f));   
       }
    
       static bool IsApproximatelyEqual(float value1, float value2, float epsilon)
       {
          // If they are equal anyway, just return True.
          if (value1.Equals(value2))
             return true;
    
          // Handle NaN, Infinity.
          if (Double.IsInfinity(value1) | Double.IsNaN(value1))
             return value1.Equals(value2);
          else if (Double.IsInfinity(value2) | Double.IsNaN(value2))
             return value1.Equals(value2);
    
          // Handle zero to avoid division by zero
          double divisor = Math.Max(value1, value2);
          if (divisor.Equals(0)) 
             divisor = Math.Min(value1, value2);
          
          return Math.Abs(value1 - value2)/divisor <= epsilon;           
       } 
    }
    // The example displays the following output:
    //       1 = 1.00000012: False
    //       1 is approximately equal to 1.00000012: True
    
    Module Example
       Public Sub Main()
          Dim one1 As Single = .1 * 10
          Dim one2 As Single = 0
          For ctr As Integer = 1 To 10
             one2 += CSng(.1)
          Next
          Console.WriteLine("{0:R} = {1:R}: {2}", one1, one2, one1.Equals(one2))
          Console.WriteLine("{0:R} is approximately equal to {1:R}: {2}", 
                            one1, one2, 
                            IsApproximatelyEqual(one1, one2, .000001))   
       End Sub
    
       Function IsApproximatelyEqual(value1 As Single, value2 As Single, 
                                     epsilon As Single) As Boolean
          ' If they are equal anyway, just return True.
          If value1.Equals(value2) Then Return True
          
          ' Handle NaN, Infinity.
          If Single.IsInfinity(value1) Or Single.IsNaN(value1) Then
             Return value1.Equals(value2)
          Else If Single.IsInfinity(value2) Or Single.IsNaN(value2)
             Return value1.Equals(value2)
          End If
          
          ' Handle zero to avoid division by zero
          Dim divisor As Single = Math.Max(value1, value2)
          If divisor.Equals(0) Then
             divisor = Math.Min(value1, value2)
          End If 
          
          Return Math.Abs(value1 - value2)/divisor <= epsilon           
       End Function
    End Module
    ' The example displays the following output:
    '       1 = 1.00000012: False
    '       1 is approximately equal to 1.00000012: True
    

Kayan nokta değerleri ve özel durumlarFloating-point values and exceptions

Kayan nokta değerlerine sahip işlemler özel durumlar oluşturmaz, tam sayı türlerine sahip işlemlerden farklı olarak, sıfıra bölme veya taşma gibi geçersiz işlemler gibi özel durumlar oluşturur.Operations with floating-point values do not throw exceptions, unlike operations with integral types, which throw exceptions in cases of illegal operations such as division by zero or overflow. Bunun yerine, bu durumlarda kayan nokta işleminin sonucu sıfır, pozitif sonsuzluk, negatif sonsuz veya sayı değil (NaN):Instead, in these situations, the result of a floating-point operation is zero, positive infinity, negative infinity, or not a number (NaN):

  • Kayan noktalı bir işlemin sonucu hedef biçim için çok küçükse, sonuç sıfırdır.If the result of a floating-point operation is too small for the destination format, the result is zero. Aşağıdaki örnekte gösterildiği gibi, iki çok küçük kayan nokta numarası çarpçıktığında bu durum oluşabilir.This can occur when two very small floating-point numbers are multiplied, as the following example shows.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = 1.163287e-36f;
          float value2 = 9.164234e-25f;
          float result = value1 * value2;
          Console.WriteLine("{0} * {1} = {2}", value1, value2, result);
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0.0f));
       }
    }
    // The example displays the following output:
    //       1.163287E-36 * 9.164234E-25 = 0
    //       0 = 0: True
    
    Module Example
       Public Sub Main()
          Dim value1 As Single = 1.163287e-36
          Dim value2 As Single = 9.164234e-25
          Dim result As Single = value1 * value2
          Console.WriteLine("{0} * {1} = {2:R}", value1, value2, result)
          Console.WriteLine("{0} = 0: {1}", result, result.Equals(0))
       End Sub
    End Module
    ' The example displays the following output:
    '       1.163287E-36 * 9.164234E-25 = 0
    '       0 = 0: True
    
  • Bir kayan nokta işleminin sonucunun büyüklüğü hedef biçimin aralığını aşarsa, işlemin sonucu, sonucun işaretine uygun olarak PositiveInfinity veya NegativeInfinity.If the magnitude of the result of a floating-point operation exceeds the range of the destination format, the result of the operation is PositiveInfinity or NegativeInfinity, as appropriate for the sign of the result. Single.MaxValue taşan bir işlemin sonucu PositiveInfinityve Single.MinValue taşan bir işlemin sonucu, aşağıdaki örnekte gösterildiği gibi NegativeInfinity.The result of an operation that overflows Single.MaxValue is PositiveInfinity, and the result of an operation that overflows Single.MinValue is NegativeInfinity, as the following example shows.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          float value1 = 3.065e35f;
          float value2 = 6.9375e32f;
          float result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}\n", 
                            Single.IsNegativeInfinity(result));
    
          value1 = -value1;
          result = value1 * value2;
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result));
          Console.WriteLine("NegativeInfinity: {0}", 
                            Single.IsNegativeInfinity(result));
       }
    }                                                                 
    
    // The example displays the following output:
    //       PositiveInfinity: True
    //       NegativeInfinity: False
    //       
    //       PositiveInfinity: False
    //       NegativeInfinity: True
    
    Module Example
       Public Sub Main()
          Dim value1 As Single = 3.065e35
          Dim value2 As Single = 6.9375e32
          Dim result As Single = value1 * value2
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result))
          Console.WriteLine("NegativeInfinity: {0}", 
                            Single.IsNegativeInfinity(result))
          Console.WriteLine()                  
          value1 = -value1
          result = value1 * value2
          Console.WriteLine("PositiveInfinity: {0}", 
                             Single.IsPositiveInfinity(result))
          Console.WriteLine("NegativeInfinity: {0}", 
                            Single.IsNegativeInfinity(result))
       End Sub
    End Module
    ' The example displays the following output:
    '       PositiveInfinity: True
    '       NegativeInfinity: False
    '       
    '       PositiveInfinity: False
    '       NegativeInfinity: True
    

    PositiveInfinity Ayrıca, pozitif bir bölünmeyle bölme sıfıra NegativeInfinity ve sıfıra bölünen bir bölme sonucu negatif bir bölünmeyle sonuçlanır.PositiveInfinity also results from a division by zero with a positive dividend, and NegativeInfinity results from a division by zero with a negative dividend.

  • Kayan noktalı bir işlem geçersizse, işlemin sonucu NaN.If a floating-point operation is invalid, the result of the operation is NaN. Örneğin, aşağıdaki işlemlerden sonuçları NaN:For example, NaN results from the following operations:

    • Sıfıra bölünen sıfıra bölme.Division by zero with a dividend of zero. Sıfıra göre bölmeyle ilgili diğer durumların PositiveInfinity ya da NegativeInfinitysonucu olduğunu unutmayın.Note that other cases of division by zero result in either PositiveInfinity or NegativeInfinity.

    • Geçersiz girişe sahip herhangi bir kayan nokta işlemi.Any floating-point operation with invalid input. Örneğin, negatif bir değerin kare kökünü bulmaya çalışmak NaNdöndürür.For example, attempting to find the square root of a negative value returns NaN.

    • Değeri Single.NaNolan bir bağımsız değişkene sahip herhangi bir işlem.Any operation with an argument whose value is Single.NaN.

Tür dönüştürmeleri ve tek yapıType conversions and the Single structure

Single yapısı herhangi bir açık veya örtük dönüştürme işleci tanımlamaz; Bunun yerine, dönüştürmeler derleyici tarafından uygulanır.The Single structure does not define any explicit or implicit conversion operators; instead, conversions are implemented by the compiler.

Aşağıdaki tabloda, diğer ilkel sayısal türlerin bir değerinin Single bir değere yönelik olası dönüştürmeleri listelenmektedir. Ayrıca, dönüştürmenin genişleyen mı yoksa daraltma mi olduğunu ve sonuçta elde edilen Single orijinal değerden daha az duyarlığa sahip olup olmadığını gösterir.The following table lists the possible conversions of a value of the other primitive numeric types to a Single value, It also indicates whether the conversion is widening or narrowing and whether the resulting Single may have less precision than the original value.

DönüştürmeConversion from Genişletme/daraltmaWidening/narrowing Olası duyarlık kaybıPossible loss of precision
Byte GenişletmeWidening HayırNo
Decimal GenişletmeWidening

Bir atama C# işleci gerektirdiğini unutmayın.Note that C# requires a cast operator.
Evet.Yes. Decimal, duyarlılığı 29 ondalık basamaklarını destekler; Single 9 destekler.Decimal supports 29 decimal digits of precision; Single supports 9.
Double Daraltma Aralık dışı değerler Double.NegativeInfinity veya Double.PositiveInfinitydönüştürülür.Narrowing; out-of-range values are converted to Double.NegativeInfinity or Double.PositiveInfinity. Evet.Yes. Double, Duyarlığın ondalık basamaklarını destekler; Single 9 destekler.Double supports 17 decimal digits of precision; Single supports 9.
Int16 GenişletmeWidening HayırNo
Int32 GenişletmeWidening Evet.Yes. Int32 duyarlık için 10 ondalık basamağı destekler; Single 9 destekler.Int32 supports 10 decimal digits of precision; Single supports 9.
Int64 GenişletmeWidening Evet.Yes. Int64, Duyarlığın ondalık basamaklarını destekler; Single 9 destekler.Int64 supports 19 decimal digits of precision; Single supports 9.
SByte GenişletmeWidening HayırNo
UInt16 GenişletmeWidening HayırNo
UInt32 GenişletmeWidening Evet.Yes. UInt32 duyarlık için 10 ondalık basamağı destekler; Single 9 destekler.UInt32 supports 10 decimal digits of precision; Single supports 9.
UInt64 GenişletmeWidening Evet.Yes. Int64 duyarlık 20 ondalık basamak destekler; Single 9 destekler.Int64 supports 20 decimal digits of precision; Single supports 9.

Aşağıdaki örnek, diğer basit sayısal türlerin minimum veya maksimum değerini bir Single değerine dönüştürür.The following example converts the minimum or maximum value of other primitive numeric types to a Single value.

using System;

public class Example
{
   public static void Main()
   {
      dynamic[] values = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                           Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                           Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                           Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                           SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                           UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                           UInt64.MinValue, UInt64.MaxValue };
      float sngValue;
      foreach (var value in values) {
         if (value.GetType() == typeof(Decimal) ||
             value.GetType() == typeof(Double))
            sngValue = (float) value;
         else
            sngValue = value;
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           sngValue, sngValue.GetType().Name);
      }
   }
}
// The example displays the following output:
//       0 (Byte) --> 0 (Single)
//       255 (Byte) --> 255 (Single)
//       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
//       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
//       -1.79769313486232E+308 (Double) --> -Infinity (Single)
//       1.79769313486232E+308 (Double) --> Infinity (Single)
//       -32768 (Int16) --> -32768 (Single)
//       32767 (Int16) --> 32767 (Single)
//       -2147483648 (Int32) --> -2.14748365E+09 (Single)
//       2147483647 (Int32) --> 2.14748365E+09 (Single)
//       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
//       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
//       -128 (SByte) --> -128 (Single)
//       127 (SByte) --> 127 (Single)
//       0 (UInt16) --> 0 (Single)
//       65535 (UInt16) --> 65535 (Single)
//       0 (UInt32) --> 0 (Single)
//       4294967295 (UInt32) --> 4.2949673E+09 (Single)
//       0 (UInt64) --> 0 (Single)
//       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)
Module Example
   Public Sub Main()
      Dim values() As Object = { Byte.MinValue, Byte.MaxValue, Decimal.MinValue,
                                 Decimal.MaxValue, Double.MinValue, Double.MaxValue,
                                 Int16.MinValue, Int16.MaxValue, Int32.MinValue,
                                 Int32.MaxValue, Int64.MinValue, Int64.MaxValue,
                                 SByte.MinValue, SByte.MaxValue, UInt16.MinValue,
                                 UInt16.MaxValue, UInt32.MinValue, UInt32.MaxValue,
                                 UInt64.MinValue, UInt64.MaxValue }
      Dim sngValue As Single
      For Each value In values
         If value.GetType() = GetType(Double) Then
            sngValue = CSng(value)
         Else
            sngValue = value
         End If
         Console.WriteLine("{0} ({1}) --> {2:R} ({3})",
                           value, value.GetType().Name,
                           sngValue, sngValue.GetType().Name)
      Next
   End Sub
End Module
' The example displays the following output:
'       0 (Byte) --> 0 (Single)
'       255 (Byte) --> 255 (Single)
'       -79228162514264337593543950335 (Decimal) --> -7.92281625E+28 (Single)
'       79228162514264337593543950335 (Decimal) --> 7.92281625E+28 (Single)
'       -1.79769313486232E+308 (Double) --> -Infinity (Single)
'       1.79769313486232E+308 (Double) --> Infinity (Single)
'       -32768 (Int16) --> -32768 (Single)
'       32767 (Int16) --> 32767 (Single)
'       -2147483648 (Int32) --> -2.14748365E+09 (Single)
'       2147483647 (Int32) --> 2.14748365E+09 (Single)
'       -9223372036854775808 (Int64) --> -9.223372E+18 (Single)
'       9223372036854775807 (Int64) --> 9.223372E+18 (Single)
'       -128 (SByte) --> -128 (Single)
'       127 (SByte) --> 127 (Single)
'       0 (UInt16) --> 0 (Single)
'       65535 (UInt16) --> 65535 (Single)
'       0 (UInt32) --> 0 (Single)
'       4294967295 (UInt32) --> 4.2949673E+09 (Single)
'       0 (UInt64) --> 0 (Single)
'       18446744073709551615 (UInt64) --> 1.84467441E+19 (Single)

Ayrıca, Double değerleri Double.NaN, Double.PositiveInfinityve Double.NegativeInfinity sırasıyla Single.NaN, Single.PositiveInfinityve Single.NegativeInfinitydönüştürür.In addition, the Double values Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity convert to Single.NaN, Single.PositiveInfinity, and Single.NegativeInfinity, respectively.

Bazı sayısal türlerin değeri Single bir değere dönüştürmenin duyarlık kaybı olabileceğini unutmayın.Note that the conversion of the value of some numeric types to a Single value can involve a loss of precision. Örnekte gösterildiği gibi, Decimal, Double, Int32, Int64, UInt32ve UInt64 değerlerini Single değerlere dönüştürürken duyarlık kaybı mümkündür.As the example illustrates, a loss of precision is possible when converting Decimal, Double, Int32, Int64, UInt32, and UInt64 values to Single values.

Bir Single değerinin Double dönüştürmesi, genişleyen bir dönüştürmedir.The conversion of a Single value to a Double is a widening conversion. Double türünün Single değeri için kesin bir temsili yoksa dönüştürme duyarlık kaybına neden olabilir.The conversion may result in a loss of precision if the Double type does not have a precise representation for the Single value.

Bir Single değerinin bir Double dışındaki herhangi bir temel sayı veri türü değerine dönüştürülmesi, daraltma dönüştürmesidir ve bir atama işleci (ın C#) ya da bir dönüştürme yöntemi (Visual Basic) gerektirir.The conversion of a Single value to a value of any primitive numeric data type other than a Double is a narrowing conversion and requires a cast operator (in C#) or a conversion method (in Visual Basic). Hedef türün MinValue ve MaxValue özellikleri tarafından tanımlanan hedef veri türü aralığının dışında kalan değerler aşağıdaki tabloda gösterildiği gibi davranır.Values that are outside the range of the target data type, which are defined by the target type's MinValue and MaxValue properties, behave as shown in the following table.

Hedef türTarget type SonuçResult
Herhangi bir integral türüAny integral type Bir OverflowException özel durum, Eğer dönüştürme işaretlenmiş bir bağlamda gerçekleşirse oluşur.An OverflowException exception if the conversion occurs in a checked context.

Dönüştürme işareti kaldırılmış bir bağlamda (' de C#varsayılan) gerçekleşirse, dönüştürme işlemi başarılı olur ancak değer taşarak çıkar.If the conversion occurs in an unchecked context (the default in C#), the conversion operation succeeds but the value overflows.
Decimal OverflowException özel durumu,An OverflowException exception,

Ayrıca, Single.NaN, Single.PositiveInfinityve Single.NegativeInfinity denetlenen bağlamdaki tamsayılara dönüştürme için bir OverflowException oluşturur, ancak bu değerler işaretlenmemiş bir bağlamda tamsayılara dönüştürülürken taşma.In addition, Single.NaN, Single.PositiveInfinity, and Single.NegativeInfinity throw an OverflowException for conversions to integers in a checked context, but these values overflow when converted to integers in an unchecked context. Decimaldönüşümler için her zaman bir OverflowExceptionoluşturur.For conversions to Decimal, they always throw an OverflowException. Doubledönüşümler için sırasıyla Double.NaN, Double.PositiveInfinityve Double.NegativeInfinitydönüştürülür.For conversions to Double, they convert to Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity, respectively.

Duyarlık kaybı Single bir değeri başka bir sayısal türe dönüştürdüğüne neden olabileceğini unutmayın.Note that a loss of precision may result from converting a Single value to another numeric type. Tamsayı olmayan Single değerlerini dönüştürme durumunda, örnekteki Çıktının gösterdiği gibi, Single değer yuvarlanarak (Visual Basic gibi) veya kesilmişse (içinde C#olduğu gibi) kesirli bileşen kaybolur.In the case of converting non-integral Single values, as the output from the example shows, the fractional component is lost when the Single value is either rounded (as in Visual Basic) or truncated (as in C#). Decimal değerlere dönüştürmelerde, Single değerin hedef veri türünde kesin bir temsili olmayabilir.For conversions to Decimal values, the Single value may not have a precise representation in the target data type.

Aşağıdaki örnek, bir dizi Single değerini diğer birkaç sayısal türe dönüştürür.The following example converts a number of Single values to several other numeric types. Dönüşümler, Visual Basic (varsayılan) ve içinde C# ( işaretlenen anahtar sözcüğü nedeniyle) işaretli bir bağlamda oluşur.The conversions occur in a checked context in Visual Basic (the default) and in C# (because of the checked keyword). Örneğin çıktısı, denetlenen bir işaretlenmeyen bağlamdaki dönüştürmelerin sonucunu gösterir.The output from the example shows the result for conversions in both a checked an unchecked context. /removeintchecks+ derleyici anahtarıyla derleyerek ve içinde C# checked bildirimine yorum yaparak Visual Basic bir işaretlenmeyen bağlamdaki dönüştürmeleri gerçekleştirebilirsiniz.You can perform conversions in an unchecked context in Visual Basic by compiling with the /removeintchecks+ compiler switch and in C# by commenting out the checked statement.

using System;

public class Example
{
   public static void Main()
   {
      float[] values = { Single.MinValue, -67890.1234f, -12345.6789f,
                         12345.6789f, 67890.1234f, Single.MaxValue,
                         Single.NaN, Single.PositiveInfinity,
                         Single.NegativeInfinity };
      checked {
         foreach (var value in values) {
            try {
                Int64 lValue = (long) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  lValue, lValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Int64.", value);
            }
            try {
                UInt64 ulValue = (ulong) value;
                Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                                  value, value.GetType().Name,
                                  ulValue, ulValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to UInt64.", value);
            }
            try {
                Decimal dValue = (decimal) value;
                Console.WriteLine("{0} ({1}) --> {2} ({3})",
                                  value, value.GetType().Name,
                                  dValue, dValue.GetType().Name);
            }
            catch (OverflowException) {
               Console.WriteLine("Unable to convert {0} to Decimal.", value);
            }

            Double dblValue = value;
            Console.WriteLine("{0} ({1}) --> {2} ({3})",
                              value, value.GetType().Name,
                              dblValue, dblValue.GetType().Name);
            Console.WriteLine();
         }
      }
   }
}
// The example displays the following output for conversions performed
// in a checked context:
//       Unable to convert -3.402823E+38 to Int64.
//       Unable to convert -3.402823E+38 to UInt64.
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       Unable to convert -67890.13 to UInt64.
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       Unable to convert -12345.68 to UInt64.
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       Unable to convert 3.402823E+38 to Int64.
//       Unable to convert 3.402823E+38 to UInt64.
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       Unable to convert NaN to Int64.
//       Unable to convert NaN to UInt64.
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Unable to convert Infinity to Int64.
//       Unable to convert Infinity to UInt64.
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       Unable to convert -Infinity to Int64.
//       Unable to convert -Infinity to UInt64.
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
// The example displays the following output for conversions performed
// in an unchecked context:
//       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -3.402823E+38 to Decimal.
//       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
//
//       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
//       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
//       -67890.13 (Single) --> -67890.12 (Decimal)
//       -67890.13 (Single) --> -67890.125 (Double)
//
//       -12345.68 (Single) --> -12345 (0xFFFFFFFFFFFFCFC7) (Int64)
//       -12345.68 (Single) --> 18446744073709539271 (0xFFFFFFFFFFFFCFC7) (UInt64)
//       -12345.68 (Single) --> -12345.68 (Decimal)
//       -12345.68 (Single) --> -12345.6787109375 (Double)
//
//       12345.68 (Single) --> 12345 (0x0000000000003039) (Int64)
//       12345.68 (Single) --> 12345 (0x0000000000003039) (UInt64)
//       12345.68 (Single) --> 12345.68 (Decimal)
//       12345.68 (Single) --> 12345.6787109375 (Double)
//
//       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
//       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
//       67890.13 (Single) --> 67890.12 (Decimal)
//       67890.13 (Single) --> 67890.125 (Double)
//
//       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert 3.402823E+38 to Decimal.
//       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
//
//       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert NaN to Decimal.
//       NaN (Single) --> NaN (Double)
//
//       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
//       Unable to convert Infinity to Decimal.
//       Infinity (Single) --> Infinity (Double)
//
//       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
//       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
//       Unable to convert -Infinity to Decimal.
//       -Infinity (Single) --> -Infinity (Double)
Module Example
   Public Sub Main()
      Dim values() As Single = { Single.MinValue, -67890.1234, -12345.6789,
                                 12345.6789, 67890.1234, Single.MaxValue,
                                 Single.NaN, Single.PositiveInfinity,
                                 Single.NegativeInfinity }
      For Each value In values
         Try
             Dim lValue As Long = CLng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               lValue, lValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Int64.", value)
         End Try
         Try
             Dim ulValue As UInt64 = CULng(value)
             Console.WriteLine("{0} ({1}) --> {2} (0x{2:X16}) ({3})",
                               value, value.GetType().Name,
                               ulValue, ulValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to UInt64.", value)
         End Try
         Try
             Dim dValue As Decimal = CDec(value)
             Console.WriteLine("{0} ({1}) --> {2} ({3})",
                               value, value.GetType().Name,
                               dValue, dValue.GetType().Name)
         Catch e As OverflowException
            Console.WriteLine("Unable to convert {0} to Decimal.", value)
         End Try

         Dim dblValue As Double = value
         Console.WriteLine("{0} ({1}) --> {2} ({3})",
                           value, value.GetType().Name,
                           dblValue, dblValue.GetType().Name)
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output for conversions performed
' in a checked context:
'       Unable to convert -3.402823E+38 to Int64.
'       Unable to convert -3.402823E+38 to UInt64.
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       Unable to convert -67890.13 to UInt64.
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       Unable to convert -12345.68 to UInt64.
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       Unable to convert 3.402823E+38 to Int64.
'       Unable to convert 3.402823E+38 to UInt64.
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       Unable to convert NaN to Int64.
'       Unable to convert NaN to UInt64.
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Unable to convert Infinity to Int64.
'       Unable to convert Infinity to UInt64.
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       Unable to convert -Infinity to Int64.
'       Unable to convert -Infinity to UInt64.
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)
' The example displays the following output for conversions performed
' in an unchecked context:
'       -3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -3.402823E+38 (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -3.402823E+38 to Decimal.
'       -3.402823E+38 (Single) --> -3.40282346638529E+38 (Double)
'
'       -67890.13 (Single) --> -67890 (0xFFFFFFFFFFFEF6CE) (Int64)
'       -67890.13 (Single) --> 18446744073709483726 (0xFFFFFFFFFFFEF6CE) (UInt64)
'       -67890.13 (Single) --> -67890.12 (Decimal)
'       -67890.13 (Single) --> -67890.125 (Double)
'
'       -12345.68 (Single) --> -12346 (0xFFFFFFFFFFFFCFC6) (Int64)
'       -12345.68 (Single) --> 18446744073709539270 (0xFFFFFFFFFFFFCFC6) (UInt64)
'       -12345.68 (Single) --> -12345.68 (Decimal)
'       -12345.68 (Single) --> -12345.6787109375 (Double)
'
'       12345.68 (Single) --> 12346 (0x000000000000303A) (Int64)
'       12345.68 (Single) --> 12346 (0x000000000000303A) (UInt64)
'       12345.68 (Single) --> 12345.68 (Decimal)
'       12345.68 (Single) --> 12345.6787109375 (Double)
'
'       67890.13 (Single) --> 67890 (0x0000000000010932) (Int64)
'       67890.13 (Single) --> 67890 (0x0000000000010932) (UInt64)
'       67890.13 (Single) --> 67890.12 (Decimal)
'       67890.13 (Single) --> 67890.125 (Double)
'
'       3.402823E+38 (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       3.402823E+38 (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert 3.402823E+38 to Decimal.
'       3.402823E+38 (Single) --> 3.40282346638529E+38 (Double)
'
'       NaN (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       NaN (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert NaN to Decimal.
'       NaN (Single) --> NaN (Double)
'
'       Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       Infinity (Single) --> 0 (0x0000000000000000) (UInt64)
'       Unable to convert Infinity to Decimal.
'       Infinity (Single) --> Infinity (Double)
'
'       -Infinity (Single) --> -9223372036854775808 (0x8000000000000000) (Int64)
'       -Infinity (Single) --> 9223372036854775808 (0x8000000000000000) (UInt64)
'       Unable to convert -Infinity to Decimal.
'       -Infinity (Single) --> -Infinity (Double)

Sayısal türlerin dönüştürülmesi hakkında daha fazla bilgi için, .NET Framework dönüştürme ve tür dönüştürme tablolarınabakın.For more information on the conversion of numeric types, see Type Conversion in the .NET Framework and Type Conversion Tables.

Kayan nokta işlevleriFloating-point functionality

Single yapısı ve ilgili türler aşağıdaki işlem kategorilerini gerçekleştirmek için yöntemler sağlar:The Single structure and related types provide methods to perform the following categories of operations:

  • Değerlerin karşılaştırması.Comparison of values. İki Single değerin eşit olup olmadığını veya iki değer arasındaki ilişkiyi belirlemede CompareTo yöntemini anlamak için Equals yöntemini çağırabilirsiniz.You can call the Equals method to determine whether two Single values are equal, or the CompareTo method to determine the relationship between two values.

    Single yapısı Ayrıca, tüm karşılaştırma işleçleri kümesini destekler.The Single structure also supports a complete set of comparison operators. Örneğin, eşitlik veya eşitsizlik için test edebilir veya bir değerin başka bir değerden büyük veya ona eşit olup olmadığını belirleyebilirsiniz.For example, you can test for equality or inequality, or determine whether one value is greater than or equal to another value. İşlenenden biri bir Doubleise, Single değeri karşılaştırma gerçekleştirilmeden önce Double dönüştürülür.If one of the operands is a Double, the Single value is converted to a Double before performing the comparison. İşlenenden biri integral bir tür ise, karşılaştırma gerçekleştirilmeden önce Single dönüştürülür.If one of the operands is an integral type, it is converted to a Single before performing the comparison. Bunlar, genişleyen dönüştürmeler olsa da duyarlık kaybı içerebilir.Although these are widening conversions, they may involve a loss of precision.

    Uyarı

    Duyarlılığın farklılığı nedeniyle, eşit olmasını düşündüğünüz iki Single değeri eşit olacak şekilde kapatabilir, bu da karşılaştırmanın sonucunu etkiler.Because of differences in precision, two Single values that you expect to be equal may turn out to be unequal, which affects the result of the comparison. İki Single değerini karşılaştırma hakkında daha fazla bilgi için eşitlik Için test etme bölümüne bakın.See the Testing for equality section for more information about comparing two Single values.

    Ayrıca, bu özel değerleri sınamak için IsNaN, IsInfinity, IsPositiveInfinityve IsNegativeInfinity yöntemlerini çağırabilirsiniz.You can also call the IsNaN, IsInfinity, IsPositiveInfinity, and IsNegativeInfinity methods to test for these special values.

  • Matematik işlemleri.Mathematical operations. Toplama, çıkarma, çarpma ve bölme gibi yaygın aritmetik işlemler, Single Yöntemler yerine dil derleyicileri ve ortak ara dil (CıL) yönergeleri tarafından uygulanır.Common arithmetic operations such as addition, subtraction, multiplication, and division are implemented by language compilers and Common Intermediate Language (CIL) instructions rather than by Single methods. Bir matematiksel işlemdeki diğer işlenen Double, işlem gerçekleştirilmeden önce Single Double dönüştürülür ve işlemin sonucu da bir Double değeridir.If the other operand in a mathematical operation is a Double, the Single is converted to a Double before performing the operation, and the result of the operation is also a Double value. Diğer işlenen bir integral türü ise, işlem gerçekleştirilmeden önce Single dönüştürülür ve işlemin sonucu aynı zamanda bir Single değeridir.If the other operand is an integral type, it is converted to a Single before performing the operation, and the result of the operation is also a Single value.

    System.Math sınıfındaki static (Shared Visual Basic) yöntemlerine çağırarak diğer matematik işlemlerini gerçekleştirebilirsiniz.You can perform other mathematical operations by calling static (Shared in Visual Basic) methods in the System.Math class. Bunlar, genellikle aritmetik (Math.Abs, Math.Signve Math.Sqrt), geometri (Math.Cos ve Math.Singibi) ve anormal (örneğin, Math.Log) için kullanılan ek yöntemleri içerir.These include additional methods commonly used for arithmetic (such as Math.Abs, Math.Sign, and Math.Sqrt), geometry (such as Math.Cos and Math.Sin), and calculus (such as Math.Log). Her durumda Single değeri bir Doubledönüştürülür.In all cases, the Single value is converted to a Double.

    Ayrıca, bir Single değerindeki ayrı bitleri de değiştirebilirsiniz.You can also manipulate the individual bits in a Single value. BitConverter.GetBytes(Single) yöntemi, bir bayt dizisindeki bit modelini döndürür.The BitConverter.GetBytes(Single) method returns its bit pattern in a byte array. Bu bayt dizisini BitConverter.ToInt32 yöntemine geçirerek, Single değerinin bit modelini 32 bitlik bir tamsayı içinde de koruyabilirsiniz.By passing that byte array to the BitConverter.ToInt32 method, you can also preserve the Single value's bit pattern in a 32-bit integer.

  • Yuvarlama.Rounding. Yuvarlama, genellikle kayan nokta temsili ve duyarlık sorunlarından kaynaklanan değerler arasındaki farklılıkların etkilerini azaltmak için bir teknik olarak kullanılır.Rounding is often used as a technique for reducing the impact of differences between values caused by problems of floating-point representation and precision. Math.Round yöntemini çağırarak Single bir değeri yuvarlayaseçebilirsiniz.You can round a Single value by calling the Math.Round method. Ancak, yöntem çağrılmadan önce Single değeri Double dönüştürülür ve dönüştürme bir duyarlık kaybı içerebilir.However, note that the Single value is converted to a Double before the method is called, and the conversion can involve a loss of precision.

  • Biçimlendirme.Formatting. ToString yöntemini çağırarak veya Bileşik biçimlendirme özelliğini kullanarak Single bir değeri dize gösterimine dönüştürebilirsiniz.You can convert a Single value to its string representation by calling the ToString method or by using the composite formatting feature. Biçim dizelerinin kayan nokta değerlerinin dize gösterimini nasıl denetdiği hakkında bilgi için bkz. Standart sayısal biçim dizeleri ve özel sayısal biçim dizeleri konuları.For information about how format strings control the string representation of floating-point values, see the Standard Numeric Format Strings and Custom Numeric Format Strings topics.

  • Dizeleri ayrıştırma.Parsing strings. Parse veya TryParse yöntemini çağırarak kayan noktalı bir değerin dize gösterimini Single değere dönüştürebilirsiniz.You can convert the string representation of a floating-point value to a Single value by calling the Parse or TryParse method. Ayrıştırma işlemi başarısız olursa, Parse metodu bir özel durum oluşturur, ancak TryParse yöntemi falsedöndürür.If the parse operation fails, the Parse method throws an exception, whereas the TryParse method returns false.

  • Tür dönüştürme.Type conversion. Single yapısı, iki standart .NET Framework veri türü arasında dönüştürmeyi destekleyen IConvertible arabirimi için açık arabirim uygulamaları sağlar.The Single structure provides an explicit interface implementation for the IConvertible interface, which supports conversion between any two standard .NET Framework data types. Dil derleyicileri, Double Single değerlere dönüştürülmesi dışında, diğer tüm standart sayısal türler için değerlerin örtük dönüştürülmesini da destekler.Language compilers also support the implicit conversion of values for all other standard numeric types except for the conversion of Double to Single values. Bir Double dışındaki standart sayısal tür bir değerin bir Single dönüşümü, genişleyen bir dönüştürmedir ve bir atama işleci ya da dönüştürme yönteminin kullanılmasını gerektirmez.Conversion of a value of any standard numeric type other than a Double to a Single is a widening conversion and does not require the use of a casting operator or conversion method.

    Ancak, 32-bit ve 64 bit tamsayı değerlerinin dönüştürülmesi duyarlık kaybı içerebilir.However, conversion of 32-bit and 64-bit integer values can involve a loss of precision. Aşağıdaki tabloda 32 bit, 64 bit ve Double türleri için duyarlık 'teki farklılıklar listelenmiştir:The following table lists the differences in precision for 32-bit, 64-bit, and Double types:

    TürType En büyük duyarlık (ondalık basamaklar)Maximum precision (in decimal digits) İç duyarlık (ondalık basamaklar)Internal precision (in decimal digits)
    Double 1515 1717
    Int32 ve UInt32Int32 and UInt32 1010 1010
    Int64 ve UInt64Int64 and UInt64 1919 1919
    Single 77 99

    En sık duyarlık sorunu, Double değerlere dönüştürülen Single değerleri etkiler.The problem of precision most frequently affects Single values that are converted to Double values. Aşağıdaki örnekte, değerlerden biri Doubledönüştürülecek tek duyarlıklı kayan nokta değeri olduğundan, özdeş bölme işlemleri tarafından üretilen iki değer eşit değildir.In the following example, two values produced by identical division operations are unequal, because one of the values is a single-precision floating point value that is converted to a Double.

    using System;
    
    public class Example
    {
       public static void Main()
       {
          Double value1 = 1/3.0;
          Single sValue2 = 1/3.0f;
          Double value2 = (Double) sValue2;
          Console.WriteLine("{0:R} = {1:R}: {2}", value1, value2, 
                                              value1.Equals(value2));
       }
    }
    // The example displays the following output:
    //        0.33333333333333331 = 0.3333333432674408: False
    
    Module Example
       Public Sub Main()
          Dim value1 As Double = 1/3
          Dim sValue2 As Single = 1/3
          Dim value2 As Double = CDbl(sValue2)
          Console.WriteLine("{0} = {1}: {2}", value1, value2, value1.Equals(value2))
       End Sub
    End Module
    ' The example displays the following output:
    '       0.33333333333333331 = 0.3333333432674408: False
    

Alanlar

Epsilon

Sıfırdan büyük olan en küçük pozitif Single değerini temsil eder.Represents the smallest positive Single value that is greater than zero. Bu alan sabittir.This field is constant.

MaxValue

Singleen büyük olası değeri temsil eder.Represents the largest possible value of Single. Bu alan sabittir.This field is constant.

MinValue

Singleen küçük olası değeri temsil eder.Represents the smallest possible value of Single. Bu alan sabittir.This field is constant.

NaN

Sayı değil (NaN).Represents not a number (NaN). Bu alan sabittir.This field is constant.

NegativeInfinity

Negatif sonsuzu temsil eder.Represents negative infinity. Bu alan sabittir.This field is constant.

PositiveInfinity

Pozitif sonsuzu temsil eder.Represents positive infinity. Bu alan sabittir.This field is constant.

Yöntemler

CompareTo(Object)

Bu örneği belirtilen bir nesneyle karşılaştırır ve bu örneğin değerinin belirtilen nesnenin değerinden küçük, eşit veya daha büyük olup olmadığını belirten bir tamsayı döndürür.Compares this instance to a specified object and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified object.

CompareTo(Single)

Bu örneği belirtilen tek duyarlıklı kayan noktalı sayıyla karşılaştırır ve bu örneğin değerinin belirtilen tek duyarlıklı kayan noktalı sayının değerinden küçük, eşit veya daha büyük olup olmadığını belirten bir tamsayı döndürür.Compares this instance to a specified single-precision floating-point number and returns an integer that indicates whether the value of this instance is less than, equal to, or greater than the value of the specified single-precision floating-point number.

Equals(Object)

Bu örneğin, belirtilen bir nesneye eşit olup olmadığını gösteren bir değeri döndürür.Returns a value indicating whether this instance is equal to a specified object.

Equals(Single)

Bu örneğin ve belirtilen Single nesnesinin aynı değeri gösterip göstermediğini gösteren bir değer döndürür.Returns a value indicating whether this instance and a specified Single object represent the same value.

GetHashCode()

Bu örneğe ilişkin karma kodu döndürür.Returns the hash code for this instance.

GetTypeCode()

Değer türü Singleiçin TypeCode döndürür.Returns the TypeCode for value type Single.

IsFinite(Single)

Belirtilen değerin sınırlı olup olmadığını belirler (sıfır, alt normal veya normal).Determines whether the specified value is finite (zero, subnormal or normal).

IsInfinity(Single)

Belirtilen sayının negatif veya pozitif sonsuz olarak değerlendirilip değerlendirilmediğini gösteren bir değer döndürür.Returns a value indicating whether the specified number evaluates to negative or positive infinity.

IsNaN(Single)

Belirtilen değerin bir sayı (NaN) olmadığını gösteren bir değer döndürür.Returns a value that indicates whether the specified value is not a number (NaN).

IsNegative(Single)

Belirtilen değerin negatif olup olmadığını belirler.Determines whether the specified value is negative.

IsNegativeInfinity(Single)

Belirtilen sayının negatif sonsuz olarak değerlendirilip değerlendirilmediğini gösteren bir değer döndürür.Returns a value indicating whether the specified number evaluates to negative infinity.

IsNormal(Single)

Belirtilen değerin normal olup olmadığını belirler.Determines whether the specified value is normal.

IsPositiveInfinity(Single)

Belirtilen sayının pozitif sonsuzluk olarak değerlendirilip değerlendirilmediğini gösteren bir değer döndürür.Returns a value indicating whether the specified number evaluates to positive infinity.

IsSubnormal(Single)

Belirtilen değerin alt normal olup olmadığını belirler.Determines whether the specified value is subnormal.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Belirtilen bir stil ve kültüre özgü biçimdeki bir sayının dize gösterimini içeren bir karakter aralığını tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.Converts a character span that contains the string representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent.

Parse(String)

Bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.Converts the string representation of a number to its single-precision floating-point number equivalent.

Parse(String, IFormatProvider)

Belirli bir kültüre özgü biçimdeki bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.Converts the string representation of a number in a specified culture-specific format to its single-precision floating-point number equivalent.

Parse(String, NumberStyles)

Belirtilen bir stildeki bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.Converts the string representation of a number in a specified style to its single-precision floating-point number equivalent.

Parse(String, NumberStyles, IFormatProvider)

Belirtilen bir stil ve kültüre özgü biçimdeki bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.Converts the string representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent.

ToString()

Bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür.Converts the numeric value of this instance to its equivalent string representation.

ToString(IFormatProvider)

Bu örneğin sayısal değerini belirtilen kültüre özgü biçim bilgilerini kullanarak eşdeğer dize gösterimine dönüştürür.Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information.

ToString(String)

Bu örneğin sayısal değerini, belirtilen biçimi kullanarak eşdeğer dize gösterimine dönüştürür.Converts the numeric value of this instance to its equivalent string representation, using the specified format.

ToString(String, IFormatProvider)

Bu örneğin sayısal değerini belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak eşdeğer dize gösterimine dönüştürür.Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Geçerli float Number örneğinin değerini, belirtilen karakter aralığına biçimlendirmeye çalışır.Tries to format the value of the current float number instance into the provided span of characters.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)

Belirtilen bir stilin ve kültüre özgü biçimdeki bir sayının span gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.Converts the span representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent. Dönüştürmenin başarılı veya başarısız olduğunu gösteren dönüş değeri.A return value indicates whether the conversion succeeded or failed.

TryParse(ReadOnlySpan<Char>, Single)

Bir karakter alanındaki bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.Converts the string representation of a number in a character span to its single-precision floating-point number equivalent. Dönüştürmenin başarılı veya başarısız olduğunu gösteren dönüş değeri.A return value indicates whether the conversion succeeded or failed.

TryParse(String, NumberStyles, IFormatProvider, Single)

Belirtilen bir stil ve kültüre özgü biçimdeki bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.Converts the string representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent. Dönüştürmenin başarılı veya başarısız olduğunu gösteren dönüş değeri.A return value indicates whether the conversion succeeded or failed.

TryParse(String, Single)

Bir sayının dize gösterimini tek duyarlıklı kayan noktalı sayı eşdeğerine dönüştürür.Converts the string representation of a number to its single-precision floating-point number equivalent. Dönüştürmenin başarılı veya başarısız olduğunu gösteren dönüş değeri.A return value indicates whether the conversion succeeded or failed.

İşleçler

Equality(Single, Single)

Belirtilen iki Single değerinin eşit olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether two specified Single values are equal.

GreaterThan(Single, Single)

Belirtilen bir Single değerinin, belirtilen başka bir Single değerinden büyük olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a specified Single value is greater than another specified Single value.

GreaterThanOrEqual(Single, Single)

Belirtilen bir Single değerinin, belirtilen başka bir Single değerinden büyük veya ona eşit olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a specified Single value is greater than or equal to another specified Single value.

Inequality(Single, Single)

Belirtilen iki Single değerinin eşit olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether two specified Single values are not equal.

LessThan(Single, Single)

Belirtilen bir Single değerinin, belirtilen başka bir Single değerinden daha az olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a specified Single value is less than another specified Single value.

LessThanOrEqual(Single, Single)

Belirtilen bir Single değerinin, belirtilen başka bir Single değerinden küçük veya ona eşit olup olmadığını gösteren bir değer döndürür.Returns a value that indicates whether a specified Single value is less than or equal to another specified Single value.

Belirtik Arabirim Kullanımları

IComparable.CompareTo(Object)
IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider)

Bu üyenin açıklaması için bkz. ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Bu üyenin açıklaması için bkz. ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Bu dönüşüm desteklenmiyor.This conversion is not supported. Bu yöntemi kullanma girişimi bir InvalidCastExceptionoluşturur.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDateTime(IFormatProvider)

Bu dönüşüm desteklenmiyor.This conversion is not supported. Bu yöntemi kullanma girişimi bir InvalidCastExceptionoluşturur.Attempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider)

Bu üyenin açıklaması için bkz. ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Bu üyenin açıklaması için bkz. ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Bu üyenin açıklaması için bkz. ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Bu üyenin açıklaması için bkz. ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Bu üyenin açıklaması için bkz. ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Bu üyenin açıklaması için bkz. ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Bu üyenin açıklaması için bkz. ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

Bu üyenin açıklaması için bkz. ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Bu üyenin açıklaması için bkz. ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Bu üyenin açıklaması için bkz. ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Bu üyenin açıklaması için bkz. ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

Şunlara uygulanır

İş Parçacığı Güvenliği

Bu türün tüm üyeleri iş parçacığı güvenlidir.All members of this type are thread safe. Örneğin durumunu değiştirmek için görüntülenen üyeler, gerçekte yeni değer ile başlatılan yeni bir örneği döndürür.Members that appear to modify instance state actually return a new instance initialized with the new value. Diğer türlerde olduğu gibi, bu türün örneğini içeren paylaşılan değişkenini okuma ve yazma, iş parçacığı güvenliğini sağlamak için bir kilit tarafından korunmalıdır.As with any other type, reading and writing to a shared variable that contains an instance of this type must be protected by a lock to guarantee thread safety.

Ayrıca bkz.