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.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
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
[<System.Serializable>]
type single = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
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

SingleDeğer türü, negatif 3.402823 E38 ile pozitif 3.402823 E38 arasında değişen değerleri olan tek duyarlıklı 32 bitlik bir sayıyı temsil eder ve pozitif veya negatif sıfır,, PositiveInfinity NegativeInfinity ,, sayı değil ( NaN ).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) ya da son derece küçük (örneğin, dünya çapında başka bir Solar sistemine olan mesafe) olan 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). SingleTür, ikili kayan nokta aritmetiği IÇIN ıec 60559:1989 (ıeee 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 , bir örneğin değerini dize gösterimine dönüştürmek ve bir sayının dize gösterimini bu türün örneğine dönüştürmek için, bu türün örneklerini karşılaştırmak 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

SingleVeri türü, aşağıdaki tabloda gösterildiği gibi tek duyarlıklı kayan nokta değerlerini 32 bitlik bir 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ümPart 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) tam olarak temsil etmediği için Math.PI , 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ırt biti, yalnızca iki Single değeri "R" Standart sayısal biçim dizesikullanarak görüntülediğinizde görünür ve bu, gerekirse, tür tarafından desteklenen tüm 9 basamaklı duyarlık değerlerini görüntüler Single .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ğer 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 yöntemine yapılan bir çağrı olmadığını Equals 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)Deyimdeki biçim öğelerini ve ' den ' e değiştirirseniz {0} {1} {0:R} ve {1:R} iki değerin tüm önemli rakamlarını görüntülediğinizde Single , toplama işlemleri sırasında duyarlık kaybı nedeniyle iki değerin eşit olduğundan net olur.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, bu sorun, Math.Round(Double, Int32) Single karşılaştırmayı gerçekleştirmeden önce değerleri istenen duyarlığa yuvarlamak için metodu ç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 tür Decimal yerine türü kullanın Single .When accuracy in numeric operations with fractional values is important, use the Decimal type instead of the Single type. Ya da tür aralığının ötesinde tamsayı değerleri olan sayısal işlemlerdeki doğruluk Int64 önemli olduğunda UInt64 , BigInteger türü 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 değer, bir işlem orijinal kayan nokta numarası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 sayısı özgün kayan noktalı sayıya eşittir.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ğer 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, değerlerin tam hassasiyetini korumak için "G9" Standart sayısal biçim dizesi kullanılarak değerler başarıyla yuvarlayabilirsiniz Single .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 değerlere kıyasla daha az duyarlığa sahiptir Double .Single values have less precision than Double values. Single Double Double Doğruluk farklılıklarının farklılığı nedeniyle, bir benzer şekilde, genellikle bir eşdeğer değere dönüştürülmüş bir değer değere 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 bir Double değere ve bir Single değere atanır.In the following example, the result of identical division operations is assigned to a Double value and a Single value. SingleDeğer bir öğesine aktardıktan sonra Double , iki değerin karşılaştırılması 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 veri türü Double yerine veri türünü kullanın Single veya Round yöntemini her iki değerin de aynı duyarlığa sahip olacak şekilde 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ğer ö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, Equals iki değerin eşit olup olmadığını veya CompareTo iki değer arasındaki ilişkiyi belirleme yöntemine yapılan çağrıları Single , genellikle beklenmeyen sonuçlara neden olduğunu anlamak için yöntemini çağırır.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 değerin eşit olduğu şekilde (ilk değerin eşit olduğu gibi) eşit olduğu durumlarda bu şekilde Single kararlıdır.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ğer 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. İkincisi, Single başlangıçtaki değeri geri yüklemek için 3,51 ile çarpılarak, sonucun kare kökü 3,51 ile bölünü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 yöntemine yapılan bir çağrı Equals(Single) 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 değerin tüm önemli basamaklarını görüntüleyen bir sonuç dizesi döndürmek için "G9" standart biçim dizesi kullanmak, Single 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, veya yöntemini çağırmak yerine aşağıdaki teknikleri kullanabilirsiniz Equals CompareTo :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:

  • Math.RoundHer iki değerin de aynı duyarlığa sahip olduğundan emin olmak için 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 Single eşitlik için test edilirken iki değer arasındaki mesafeyi mutlak bir ölçü olarak kullanı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 veya ondan çıkarılan en küçük olası değeri ölçer Single .However, Single.Epsilon measures the smallest possible value that can be added to, or subtracted from, a Single whose value is zero. Çoğu pozitif ve negatif Single değer için değeri Single.Epsilon algılanamayacak kadar küçüktür.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, IsApproximatelyEqual iki değer arasındaki göreli farkı test eden bir 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 yönteme ve yöntemine yapılan çağrıların sonucunu da karşıtdır IsApproximatelyEqual Equals(Single) .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, PositiveInfinity NegativeInfinity sonucun işaretine uygun olarak veya olur.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. Aşağıdaki örnekte gösterildiği gibi, taşan bir işlemin sonucu Single.MaxValue PositiveInfinity ve taşan bir işlemin sonucu Single.MinValue 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ünen bir bölme ile sıfıra, sıfıra bölünen bir NegativeInfinity bölme de 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 olur NaN .If a floating-point operation is invalid, the result of the operation is NaN. Örneğin, NaN aşağıdaki işlemlerin sonuçları: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ölme için diğer durumların ya da ya da ile sonuçlandığına unutmayın PositiveInfinity NegativeInfinity .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, döndürür NaN .For example, attempting to find the square root of a negative value returns NaN.

    • Değeri olan bağımsız değişkenine sahip herhangi bir işlem Single.NaN .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

SingleYapı 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ğerine ait olası dönüşümler bir Single değere listelenmektedir, ayrıca dönüştürmenin genişletme veya daraltma olup olmadığını ve sonuçta elde edilen Single değerin özgün 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 NoNo
Decimal GenişletmeWidening

C# ' ın bir atama işleci gerektirdiğini unutmayın.Note that C# requires a cast operator.
Evet.Yes. Decimal duyarlılık için 29 ondalık basamağı destekler; Single 9 destekler.Decimal supports 29 decimal digits of precision; Single supports 9.
Double Daraltma Aralık dışı değerler veya ' a dönüştürülür Double.NegativeInfinity Double.PositiveInfinity .Narrowing; out-of-range values are converted to Double.NegativeInfinity or Double.PositiveInfinity. Evet.Yes. Double , daha fazla duyarlılık için 17 ondalık basamağı destekler; Single 9 destekler.Double supports 17 decimal digits of precision; Single supports 9.
Int16 GenişletmeWidening NoNo
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ık 'in ondalık basamak sayısını destekler; Single 9 destekler.Int64 supports 19 decimal digits of precision; Single supports 9.
SByte GenişletmeWidening NoNo
UInt16 GenişletmeWidening NoNo
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 20 ondalık basamak duyarlılığını 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ğere 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, ve değerlerini sırasıyla,, ve olarak Double Double.NaN Double.PositiveInfinity Double.NegativeInfinity Dönüştür Single.NaN Single.PositiveInfinity Single.NegativeInfinity .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ğerini bir Single 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,,,,, ve değerlerini değerlere dönüştürürken duyarlık kaybı mümkündür Decimal Double Int32 Int64 UInt32 UInt64 Single .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ğerin bir değerine dönüştürülmesi, Double genişleyen bir dönüştürmedir.The conversion of a Single value to a Double is a widening conversion. DoubleTürün değer için kesin bir temsili yoksa dönüştürme duyarlık kaybına neden olabilir Single .The conversion may result in a loss of precision if the Double type does not have a precise representation for the Single value.

SingleBir değerin bir değer olan herhangi bir ilkel sayısal veri türüne dönüştürülmesi bir Double daraltma dönüştürmesidir ve bir atama Işleci (C# ' ta) veya 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ü ve özellikleri tarafından tanımlanan hedef veri türü aralığının dışında kalan değerler MinValue MaxValue , 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ürüTarget type SonuçResult
Herhangi bir integral türüAny integral type OverflowExceptionİşaretlenmiş bir bağlamda dönüştürme gerçekleşirse bir özel durum.An OverflowException exception if the conversion occurs in a checked context.

Dönüştürme işareti kaldırılmış bir bağlamda (varsayılan olarak C# ' de) 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 Bir OverflowException özel durum,An OverflowException exception,

Ayrıca,, Single.NaN , Single.PositiveInfinity ve Single.NegativeInfinity OverflowException işaretli bir bağlamda tamsayılara dönüştürme için bir 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. Dönüştürmesi için Decimal , her zaman bir oluşturur OverflowException .For conversions to Decimal, they always throw an OverflowException. ' A dönüşümler için Double Double.NaN sırasıyla,, Double.PositiveInfinity ve Double.NegativeInfinity ' a dönüştürülür.For conversions to Double, they convert to Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity, respectively.

Kesinlik kaybı bir Single değeri başka bir sayısal türe dönüştürdüğüne yol açabilir.Note that a loss of precision may result from converting a Single value to another numeric type. Tamsayı olmayan değerleri dönüştürme durumunda, Single örnekteki Çıktının gösterdiği gibi, Single değer yuvarlanarak (Visual Basic olarak) veya kesilmişse (C# ' de 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#). Değerlere dönüşümler için Decimal , Single değer hedef veri türünde kesin bir gösterimde bulunmayabilir.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ğeri 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 C# ' de ( Checked anahtar sözcüğü nedeniyle) denetlenen 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 ve C# içinde derleme yaparak, ' ın işaretini kaldırarak Visual Basic bir işaretlenmeyen bağlamda dönüşümler gerçekleştirebilirsiniz checked .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

SingleYapı 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. Equalsİki Single değerin eşit olup olmadığını veya CompareTo iki değer arasındaki ilişkiyi belirleme yöntemini anlamak için 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.

    SingleYapı 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 ise Double , Single Double karşılaştırma gerçekleştirilmeden önce değer bir olarak öğesine 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, Single karşılaştırma gerçekleştirilmeden önce öğesine 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, Single eşit olmasını düşündüğünüz iki değerin eşit olmayan şekilde kapatılabilir duruma gelebilir ve 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 değeri karşılaştırma hakkında daha fazla bilgi için eşitlik Için test bölümüne bakın Single .See the Testing for equality section for more information about comparing two Single values.

    Ayrıca, IsNaN IsInfinity IsPositiveInfinity IsNegativeInfinity Bu özel değerleri sınamak için,, ve 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, dil derleyicileri ve Yöntemler yerine ortak ara dil (CıL) yönergeleri tarafından uygulanır Single .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 matematik işlemindeki diğer işlenen bir ise, işlem yapılmadan Double Single önce öğesine dönüştürülür Double ve işlemin sonucu da bir Double değerdir.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 yapılmadan önce öğesine dönüştürülür Single ve işlemin sonucu da bir Single değerdir.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.

    static Shared Sınıfında (Visual Basic) yöntemleri çağırarak diğer matematik işlemlerini gerçekleştirebilirsiniz System.Math .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.Sign ve gibi Math.Sqrt ), geometri (ve gibi) Math.Cos Math.Sin ve calkülabd (gibi 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ğer bir değerine dönüştürülür Double .In all cases, the Single value is converted to a Double.

    Ayrıca, bir değerde tek tek bitleri de düzenleyebilirsiniz Single .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 32 bitlik bir tamsayı içinde değerin bit stilini 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. Yöntemini çağırarak bir değeri yuvarlayaseçebilirsiniz Single Math.Round .You can round a Single value by calling the Math.Round method. Ancak, Single Yöntem çağrılmadan önce değer bir olarak dönüştürülür Double 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. Single ToString Yöntemini çağırarak veya Bileşik biçimlendirme özelliğini kullanarak 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. Or metodunu çağırarak kayan nokta değerinin dize gösterimini Single değere dönüştürebilirsiniz Parse TryParse .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 Yöntem bir özel durum atar, ancak TryParse Yöntem döndürülür false .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. SingleYapı, arabirim için açık bir arabirim uygulamasını sağlar IConvertible ve bu iki standart .NET Framework veri türü arasında dönüştürmeyi destekler.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, değerlerine dönüştürme haricinde diğer tüm standart sayısal türler için değerlerin örtük dönüştürülmesini da destekler Double Single .Language compilers also support the implicit conversion of values for all other standard numeric types except for the conversion of Double to Single values. ' A ' yerine bir standart sayısal tür değeri Double Single , genişletme 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 türler için duyarlık 'teki farklılıklar listelenmiştir Double :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

    Duyarlık sorunu en sık, Single değerlere dönüştürülen değerleri etkiler Double .The problem of precision most frequently affects Single values that are converted to Double values. Aşağıdaki örnekte, değerlerden biri bir öğesine dönüştürülen tek duyarlıklı kayan nokta değeri olduğundan, özdeş bölme işlemleri tarafından üretilen iki değer eşit değildir Double .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 değeri temsil eder Single .Represents the smallest positive Single value that is greater than zero. Bu alan sabittir.This field is constant.

MaxValue

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

MinValue

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

NaN

Sayı değil () temsil eder 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 nesnenin 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()

TypeCodeDeğer türünü döndürür Single .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ı () olmadığını gösteren bir değer döndürür NaN .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 değerin eşit olup olmadığını gösteren bir değer döndürür Single .Returns a value that indicates whether two specified Single values are equal.

GreaterThan(Single, Single)

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

GreaterThanOrEqual(Single, Single)

Belirtilen Single değerin belirtilen başka bir değerden büyük veya ona eşit olup olmadığını gösteren bir değer döndürür Single .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 değerin eşit olup olmadığını gösteren bir değer döndürür Single .Returns a value that indicates whether two specified Single values are not equal.

LessThan(Single, Single)

Belirtilen Single değerin belirtilen başka bir değerden küçük olup olmadığını gösteren bir değer döndürür Single .Returns a value that indicates whether a specified Single value is less than another specified Single value.

LessThanOrEqual(Single, Single)

Belirtilen Single değerin belirtilen başka bir değere eşit veya ondan küçük olup olmadığını gösteren bir değer döndürür Single .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)

Mevcut örneği aynı türdeki başka bir nesne ile karşılaştırır ve geçerli örneğin, diğer nesneyle aynı sıralama düzeni konumunda mı olduğunu, önünde mi olduğunu, yoksa arkasında mı olduğunu belirten bir tamsayı döndürür.Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object.

IConvertible.GetTypeCode()

TypeCodeBu örnek için döndürür.Returns the TypeCode for this instance.

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 oluşturur InvalidCastException .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 oluşturur InvalidCastException .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.