Single Single Single Single Struct

定义

表示一个单精度浮点数。Represents a single-precision floating-point number.

public value class Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct Single : IComparable, IComparable<float>, IConvertible, IEquatable<float>, IFormattable
type single = struct
    interface IFormattable
    interface IConvertible
Public Structure Single
Implements IComparable, IComparable(Of Single), IConvertible, IEquatable(Of Single), IFormattable
继承
属性
实现

注解

值类型表示单精度32位数字,其值范围从负 3.402823 e 38 到正 3.402823 e 38,以及正或负零、 PositiveInfinityNegativeInfinity和而不是数字(NaN)。 SingleThe 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). 它用于表示非常大的值(例如行星或 galaxies 之间的距离)或极小的值(例如,物质的分子质量,以千克为间隔),并且通常不精确(如从地球到另一颗太阳系的距离。).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类型符合二元浮点算法的 IEC 60559:1989 (IEEE 754)标准。The Single type complies with the IEC 60559:1989 (IEEE 754) standard for binary floating-point arithmetic.

本主题包括以下各节:This topic consists of the following sections:

System.Single提供一些方法,用于比较此类型的实例,将实例的值转换为其字符串表示形式,并将数字的字符串表示形式转换为此类型的实例。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. 有关格式规范代码如何控制值类型的字符串表示形式的信息,请参阅格式设置类型标准数字格式字符串自定义数字格式字符串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.

浮点表示形式和精度Floating-point representation and precision

Single数据类型以32位二进制格式存储单精度浮点值,如下表所示:The Single data type stores single-precision floating-point values in a 32-bit binary format, as shown in the following table:

部件Part BitsBits
有效位数或尾数Significand or mantissa 0-220-22
Exponent 23-3023-30
Sign (0 = 正,1 = 负值)Sign (0 = positive, 1 = negative) 3131

正如小数部分无法精确表示某些小数值(如1/3 或Math.PI),二进制小数无法表示某些小数值。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. 例如,2/10 以 .2 的形式精确表示为小数部分,以二进制小数0011111001001100表示,其模式为 "1100" 重复到无限大。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. 在这种情况下,浮点值提供它所表示的数字的不精确表示形式。In this case, the floating-point value provides an imprecise representation of the number that it represents. 对原始浮点值执行其他数学运算通常会增加其精度。Performing additional mathematical operations on the original floating-point value often increases its lack of precision. 例如,如果比较 .3 乘以10的结果并将 .3 添加到 3 9 次,则您将看到加法产生的结果不太精确,因为它涉及到与乘法的8个以上的操作。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. 请注意,仅当使用 "R"标准数字格式字符串显示这两个Single Single值时,此差异才明显,如有必要,将显示该类型支持的所有9位精度。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

由于某些数字不能精确表示为小数部分的二进制值,因此浮点数只能近似于实数。Because some numbers cannot be represented exactly as fractional binary values, floating-point numbers can only approximate real numbers.

所有浮点数都具有有限数量的有效数字,还决定了浮点值接近于实数的准确程度。All floating-point numbers have a limited number of significant digits, which also determines how accurately a floating-point value approximates a real number. Single值最多可有7个小数位数的精度,尽管它在内部维护最多9位数字。A Single value has up to 7 decimal digits of precision, although a maximum of 9 digits is maintained internally. 这意味着,某些浮点运算可能缺乏更改浮点值的精度。This means that some floating-point operations may lack the precision to change a floating-point value. 下面的示例定义了一个大的单精度浮点值,然后在其中添加了的积Single.Epsilon和一个千万亿。The following example defines a large single-precision floating-point value, and then adds the product of Single.Epsilon and one quadrillion to it. 但是,该产品太小,无法修改原始浮点值。However, the product is too small to modify the original floating-point value. 它的最小有效位数为千分之几,而产品中最重要的位是 10-30Its 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

浮点数的有限精度有几个后果:The limited precision of a floating-point number has several consequences:

  • 对于特定精度,看起来相等的两个浮点数可能不相等,因为其最小有效位不同。Two floating-point numbers that appear equal for a particular precision might not compare equal because their least significant digits are different. 在下面的示例中,将一系列数字添加在一起,并将其总计与预期的总数进行比较。In the following example, a series of numbers are added together, and their total is compared with their expected total. 尽管这两个值看起来是相同的,但对Equals方法的调用表示它们不是。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)语句中的格式项从{0}{1}更改为{0:R} ,并{1:R}显示这两个Single值的所有有效位,则可以清楚地表明这两个值不相等,因为在加法运算期间丢失精度。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. 在这种情况下,可以通过调用Math.Round(Double, Int32)方法来解决该问题,以便在执行比较之前将Single值舍入到所需的精度。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.

  • 如果使用的是十进制数,则使用浮点数的算术或比较运算可能不会产生相同的结果,因为二进制浮点数可能不等于十进制数。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. 前面的示例通过显示乘以 .3 乘以10的结果并将 .3 添加到 3 9 次,阐释了这一点。A previous example illustrated this by displaying the result of multiplying .3 by 10 and adding .3 to .3 nine times.

    当包含小数值的数值操作的准确性非常重要时, Decimal请使用类型而Single不是类型。When accuracy in numeric operations with fractional values is important, use the Decimal type instead of the Single type. 当具有整数值超出Int64UInt64类型范围的数值操作的准确性BigInteger很重要时,请使用类型。When accuracy in numeric operations with integral values beyond the range of the Int64 or UInt64 types is important, use the BigInteger type.

  • 如果涉及浮点数,值可能不会往返。A value might not round-trip if a floating-point number is involved. 如果某个操作将原始浮点数转换为另一种格式,则会将值转换为舍入,而反向运算会将转换后的窗体转换回浮点数,最后浮点数等于原始的浮点数。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. 往返过程可能会失败,因为在转换过程中一个或多个最小有效位会丢失或更改。The round trip might fail because one or more least significant digits are lost or changed in a conversion. 在下面的示例中, Single将三个值转换为字符串,并保存在一个文件中。In the following example, three Single values are converted to strings and saved in a file. 如输出所示,尽管值看起来相同,但还原的值并不等于原始值。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
    

    在这种情况下,可以使用 "G9"标准数字格式字符串将值成功舍入,以保留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值的精度Double低于值。Single values have less precision than Double values. 转换为看似等效DoubleDouble 值通常不等于值,因为精度存在差异。SingleA Single value that is converted to a seemingly equivalent Double often does not equal the Double value because of differences in precision. 在下面的示例中,将相同除法运算的结果分配给一个Double值和一个Single值。In the following example, the result of identical division operations is assigned to a Double value and a Single value. Double在将Single值强制转换为之后,这两个值的比较表明它们不相等。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
    

    若要避免此问题,请使用Double数据类型来代替Single数据Round类型,或使用方法,使这两个值具有相同的精度。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.

测试是否相等Testing for equality

若要将视为相等, Single两个值必须表示相同的值。To be considered equal, two Single values must represent identical values. 不过,由于值之间的精度差异,或由于一个或两个值的精度损失,应相同的浮点值通常会因其最小有效位之间的差异而不相等。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. 因此,调用Equals方法来确定两个值是否相等,或调用CompareTo方法来确定两个Single值之间的关系,通常会产生意外结果。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. 这在下面的示例中很明显,其中两个Single明显相等的值是不相等的,因为第一个值的精度为7位,而第二个值为9。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

采用不同的代码路径并以不同的方式操作的计算值通常证明不相等。Calculated values that follow different code paths and that are manipulated in different ways often prove to be unequal. 在下面的示例中, Single一个值为平方,然后计算平方根以还原原始值。In the following example, one Single value is squared, and then the square root is calculated to restore the original value. 第二Single个比3.51 和 squared 相乘,然后将结果的平方根除以3.51 来还原原始值。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. 尽管两个值看起来相同,但对Equals(Single)方法的调用指示它们不相等。Although the two values appear to be identical, a call to the Equals(Single) method indicates that they are not equal. 使用 "G9" 标准格式字符串返回显示每个Single值的所有有效位的结果字符串表明,第二个值 .0000000000001 小于第一个值。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

如果精度损失可能会影响比较结果,则可以使用以下技术,而不是调用EqualsCompareTo方法: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.Round调用方法以确保这两个值具有相同的精度。Call the Math.Round method to ensure that both values have the same precision. 下面的示例修改了上一个示例,以使用此方法,以使两个小数值相等。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
    

    请注意,精度问题仍适用于中点值的舍入。Note that the problem of precision still applies to rounding of midpoint values. 有关更多信息,请参见 Math.Round(Double, Int32, MidpointRounding) 方法。For more information, see the Math.Round(Double, Int32, MidpointRounding) method.

  • 测试近似相等性,而不是相等。Test for approximate equality instead of equality. 此方法要求您定义一个绝对量,而这两个值可能会不同,但仍相等,或者您定义较小值与较大值之间的差异。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.

    警告

    Single.Epsilon在测试相等性时,有时会将其用作两Single个值之间的距离的绝对度量值。Single.Epsilon is sometimes used as an absolute measure of the distance between two Single values when testing for equality. 但度量值为零的可添加到或从中减去的Single最小可能值。 Single.EpsilonHowever, Single.Epsilon measures the smallest possible value that can be added to, or subtracted from, a Single whose value is zero. 对于大多数正值和负值SingleSingle.Epsilon值太小,无法检测到。For most positive and negative Single values, the value of Single.Epsilon is too small to be detected. 因此,除了零值以外,不建议在测试中使用它是否相等。Therefore, except for values that are zero, we do not recommend its use in tests for equality.

    下面的示例使用后一种方法来定义IsApproximatelyEqual测试两个值之间的相对差异的方法。The following example uses the latter approach to define an IsApproximatelyEqual method that tests the relative difference between two values. 它还比较了对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
    

浮点值和异常Floating-point values and exceptions

与整数类型的操作不同,具有浮点值的操作不会引发异常,这种操作在非法操作(如被零除或溢出)的情况下会引发异常。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. 相反,在这些情况下,浮点运算的结果为零、正无穷、负无穷或非数字(NaN):Instead, in these situations, the result of a floating-point operation is zero, positive infinity, negative infinity, or not a number (NaN):

  • 如果浮点运算的结果对于目标格式来说太小,则结果为零。If the result of a floating-point operation is too small for the destination format, the result is zero. 当两个非常小的浮点数相乘时,可能会出现这种情况,如下面的示例所示。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
    
  • 如果浮点运算结果的大小超出目标格式的范围,则操作的结果为PositiveInfinityNegativeInfinity(适用于结果的符号)。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 Single.MinValue NegativeInfinity的操作的结果为,而溢出的操作的结果为,如下面的示例所示。PositiveInfinityThe 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还是由零除后被除数引起来的结果, NegativeInfinity并由零除导致负被除数的结果。PositiveInfinity also results from a division by zero with a positive dividend, and NegativeInfinity results from a division by zero with a negative dividend.

  • 如果浮点操作无效,则操作的结果为NaNIf a floating-point operation is invalid, the result of the operation is NaN. 例如, NaN以下操作的结果:For example, NaN results from the following operations:

    • 除数为零的除以零。Division by zero with a dividend of zero. 请注意,除数为零的其他情况会导致PositiveInfinityNegativeInfinityNote that other cases of division by zero result in either PositiveInfinity or NegativeInfinity.

    • 具有无效输入的任何浮点运算。Any floating-point operation with invalid input. 例如,如果尝试查找负值的平方根,则返回NaNFor example, attempting to find the square root of a negative value returns NaN.

    • 具有值为Single.NaN的参数的任何操作。Any operation with an argument whose value is Single.NaN.

类型转换和单结构Type conversions and the Single structure

Single结构不定义任何显式或隐式转换运算符; 相反,转换是由编译器实现的。The Single structure does not define any explicit or implicit conversion operators; instead, conversions are implemented by the compiler.

下表列出了其他基元数值类型的值可能转换为Single值的情况,它还指示转换是扩大还是收缩转换,以及生成Single的精度是否低于原始值。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.

Conversion from 扩大/收缩Widening/narrowing 可能丢失精度Possible loss of precision
Byte WideningWidening NoNo
Decimal WideningWidening

请注意C# ,需要强制转换运算符。Note that C# requires a cast operator.
可以。Yes. Decimal支持29个十进制数字的精度;Single支持9。Decimal supports 29 decimal digits of precision; Single supports 9.
Double 收缩超出范围的值将转换为Double.NegativeInfinity或。 Double.PositiveInfinityNarrowing; out-of-range values are converted to Double.NegativeInfinity or Double.PositiveInfinity. 可以。Yes. Double支持17个十进制数字的精度;Single支持9。Double supports 17 decimal digits of precision; Single supports 9.
Int16 WideningWidening NoNo
Int32 WideningWidening 可以。Yes. Int32支持10个十进制数字的精度;Single支持9。Int32 supports 10 decimal digits of precision; Single supports 9.
Int64 WideningWidening 可以。Yes. Int64支持精度为19个十进制数字;Single支持9。Int64 supports 19 decimal digits of precision; Single supports 9.
SByte WideningWidening NoNo
UInt16 WideningWidening NoNo
UInt32 WideningWidening 可以。Yes. UInt32支持10个十进制数字的精度;Single支持9。UInt32 supports 10 decimal digits of precision; Single supports 9.
UInt64 WideningWidening 可以。Yes. Int64支持20个十进制数字的精度;Single支持9。Int64 supports 20 decimal digits of precision; Single supports 9.

下面的示例将其他基元数值类型的最小值或最大值Single转换为值。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)

此外Double ,值Double.NaNDouble.PositiveInfinity和将Double.NegativeInfinity分别转换为Single.NaNSingle.PositiveInfinity和。Single.NegativeInfinityIn addition, the Double values Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity covert to Single.NaN, Single.PositiveInfinity, and Single.NegativeInfinity, respectively.

请注意,某些数值类型的值到Single值的转换可能会导致精度损失。Note that the conversion of the value of some numeric types to a Single value can involve a loss of precision. 如示例中所Decimal示,将、 DoubleInt32 UInt32 Int64、、和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.

Single值到的Double转换是扩大转换。The conversion of a Single value to a Double is a widening conversion. 如果Double类型没有精确的Single值表示形式,转换可能会导致精度损失。The conversion may result in a loss of precision if the Double type does not have a precise representation for the Single value.

Single值转换为任何基元数值数据类型Double (而非)的值的转换是收缩转换,需要转换运算符(在中C#)或转换方法(在 Visual Basic 中)。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). 超出目标数据类型范围的值(由目标类型的MinValueMaxValue属性定义)的行为如下表中所示。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.

目标类型Target type 结果Result
任何整型Any integral type 如果OverflowException在检查的上下文中发生转换,则为异常。An OverflowException exception if the conversion occurs in a checked context.

如果转换发生在未检查的上下文中(默认为C#),则转换操作会成功,但值溢出。If the conversion occurs in an unchecked context (the default in C#), the conversion operation succeeds but the value overflows.
Decimal OverflowException异常,An OverflowException exception,

Single.NaN此外, Single.PositiveInfinity、、和Single.NegativeInfinity将引发OverflowException ,以便转换为已检查上下文中的整数,但这些值在转换为未检查的上下文中的整数时溢出。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. 对于到Decimal的转换,它们始终OverflowException引发。For conversions to Decimal, they always throw an OverflowException. 对于到Double的转换,它们分别转换Double.PositiveInfinityDouble.NaNDouble.NegativeInfinity和。For conversions to Double, they convert to Double.NaN, Double.PositiveInfinity, and Double.NegativeInfinity, respectively.

请注意,将Single值转换为另一种数值类型可能会导致精度损失。Note that a loss of precision may result from converting a Single value to another numeric type. 在转换非整数Single值的情况下,如示例的输出所示, Single当值舍入(如 Visual Basic)或截断(如中C#)时,小数部分将丢失。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值的转换Single ,该值在目标数据类型中可能没有精确的表示形式。For conversions to Decimal values, the Single value may not have a precise representation in the target data type.

下面的示例将多个Single值转换为多个其他数值类型。The following example converts a number of Single values to several other numeric types. 转换在 Visual Basic (默认值)和中C#的已检查上下文中发生(因为有checked关键字)。The conversions occur in a checked context in Visual Basic (the default) and in C# (because of the checked keyword). 该示例的输出显示了已检查的未检查上下文中的转换结果。The output from the example shows the result for conversions in both a checked an unchecked context. 通过使用/removeintchecks+编译器开关进行编译,并C# checked通过注释掉语句,可以在 Visual Basic 的未检查上下文中执行转换。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)

有关数值类型转换的详细信息,请参阅 .NET Framework 和类型转换表中的类型转换For more information on the conversion of numeric types, see Type Conversion in the .NET Framework and Type Conversion Tables.

浮点型功能Floating-point functionality

Single结构和相关类型提供了执行以下类别的操作的方法:The Single structure and related types provide methods to perform the following categories of operations:

  • 值比较Comparison of values. 您可以调用Equals方法来确定两个Single值是否相等,或CompareTo调用方法来确定两个值之间的关系。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结构还支持一组完整的比较运算符。The Single structure also supports a complete set of comparison operators. 例如,你可以测试是否相等或不相等,或确定一个值是否大于或等于另一个值。For example, you can test for equality or inequality, or determine whether one value is greater than or equal to another value. 如果其中一个操作数为Double,则在执行比较Double之前将Single该值转换为。If one of the operands is a Double, the Single value is converted to a Double before performing the comparison. 如果其中一个操作数为整型类型,则在执行比较Single之前将其转换为。If one of the operands is an integral type, it is converted to a Single before performing the comparison. 尽管这些是扩大转换,但它们可能会损失精度。Although these are widening conversions, they may involve a loss of precision.

    警告

    由于精度之间存在差异,因此Single两个预期相等的值可能会不相等,这将影响比较的结果。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. 有关比较两个Single值的详细信息,请参阅测试相等性部分。See the Testing for equality section for more information about comparing two Single values.

    你还可以IsNaN调用、 IsInfinityIsPositiveInfinityIsNegativeInfinity方法来测试这些特殊值。You can also call the IsNaN, IsInfinity, IsPositiveInfinity, and IsNegativeInfinity methods to test for these special values.

  • 数学运算Mathematical operations. 常见算术运算(例如加法、减法、乘法和除法)由语言编译器和公共中间语言(CIL)指令实现,而不是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. 如果数学运算中Double的另一个操作数为,则在Single执行运算Double前转换为,并且操作的结果也Double是值。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. 如果另一个操作数是整数类型,则在执行运算Single前将其转换为,并且操作的结果Single也是值。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 System.Math类中的(Shared在 Visual Basic)方法来执行其他数学运算。You can perform other mathematical operations by calling static (Shared in Visual Basic) methods in the System.Math class. 其中包括通常用于算术运算的其他方法(如Math.AbsMath.SignMath.Sqrt)、几何图形(如Math.CosMath.Sin)以及微积分(如Math.Log)。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). 在所有情况下, Single值都将转换Double为。In all cases, the Single value is converted to a Double.

    您还可以操作Single值中的单个位。You can also manipulate the individual bits in a Single value. BitConverter.GetBytes(Single)方法返回其在字节数组中的位模式。The BitConverter.GetBytes(Single) method returns its bit pattern in a byte array. 通过将该字节数组传递给BitConverter.ToInt32方法,还可以在32位Single整数中保留值的位模式。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.

  • 舍入Rounding. 舍入通常用作一种方法,用于降低由于浮点表示形式和精度问题导致的值之间的差异。Rounding is often used as a technique for reducing the impact of differences between values caused by problems of floating-point representation and precision. 可以通过Single Math.Round调用方法来舍入值。You can round a Single value by calling the Math.Round method. 但请注意Single ,在调用方法Double之前,该值会转换为,并且转换可能会导致精度损失。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.

  • 格式设置Formatting. 可以通过Single ToString调用方法或使用复合格式设置功能,将值转换为其字符串表示形式。You can convert a Single value to its string representation by calling the ToString method or by using the composite formatting feature. 有关格式字符串如何控制浮点值的字符串表示形式的信息,请参阅标准数字格式字符串自定义数字格式字符串主题。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.

  • 分析字符串Parsing strings. 可以通过Single Parse调用或TryParse方法,将浮点值的字符串表示形式转换为值。You can convert the string representation of a floating-point value to a Single value by calling the Parse or TryParse method. 如果分析操作失败,则该Parse方法将引发异常, TryParse而方法返回falseIf the parse operation fails, the Parse method throws an exception, whereas the TryParse method returns false.

  • 类型转换Type conversion. Single 结构IConvertible为接口提供了显式接口实现,该接口支持任意两个标准 .NET Framework 数据类型之间的转换。The Single structure provides an explicit interface implementation for the IConvertible interface, which supports conversion between any two standard .NET Framework data types. 语言编译器还支持所有其他标准数值类型的值的隐式转换,但将转换DoubleSingle值除外。Language compilers also support the implicit conversion of values for all other standard numeric types except for the conversion of Double to Single values. 将除之外Double Single的任何标准数值类型的值转换为扩大转换,不需要使用强制转换运算符或转换方法。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.

    但是,32位和64位整数值的转换可能会导致精度损失。However, conversion of 32-bit and 64-bit integer values can involve a loss of precision. 下表列出了32位、64位和Double类型的精度差异:The following table lists the differences in precision for 32-bit, 64-bit, and Double types:

    类型Type 最大精度(十进制数字)Maximum precision (in decimal digits) 内部精度(十进制数字)Internal precision (in decimal digits)
    Double 1515 1717
    Int32UInt32Int32 and UInt32 1010 1010
    Int64UInt64Int64 and UInt64 1919 1919
    Single 77 99

    精确的问题会影响Single转换为Double值的值。The problem of precision most frequently affects Single values that are converted to Double values. 在下面的示例中,两个由相同除法运算生成的值是不相等的,因为其中一个值是转换为的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
    

字段

Epsilon Epsilon Epsilon Epsilon

表示大于零的最小正 Single 值。Represents the smallest positive Single value that is greater than zero. 此字段为常数。This field is constant.

MaxValue MaxValue MaxValue MaxValue

表示 Single 的最大可能值。Represents the largest possible value of Single. 此字段为常数。This field is constant.

MinValue MinValue MinValue MinValue

表示 Single 的最小可能值。Represents the smallest possible value of Single. 此字段为常数。This field is constant.

NaN NaN NaN NaN

表示非数字 (NaN)。Represents not a number (NaN). 此字段为常数。This field is constant.

NegativeInfinity NegativeInfinity NegativeInfinity NegativeInfinity

表示负无穷。Represents negative infinity. 此字段为常数。This field is constant.

PositiveInfinity PositiveInfinity PositiveInfinity PositiveInfinity

表示正无穷。Represents positive infinity. 此字段为常数。This field is constant.

方法

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

将此实例与指定对象进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定对象的值。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) CompareTo(Single) CompareTo(Single) CompareTo(Single)

将此实例与指定的单精度浮点数进行比较,并返回一个整数,该整数指示此实例的值是小于、等于还是大于指定单精度浮点数的值。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) Equals(Object) Equals(Object) Equals(Object)

返回一个值,该值指示此实例是否等于指定的对象。Returns a value indicating whether this instance is equal to a specified object.

Equals(Single) Equals(Single) Equals(Single) Equals(Single)

返回一个值,该值指示此实例和指定的 Single 对象是否表示相同的值。Returns a value indicating whether this instance and a specified Single object represent the same value.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

返回此实例的哈希代码。Returns the hash code for this instance.

GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

返回值类型 TypeCodeSingleReturns the TypeCode for value type Single.

IsFinite(Single) IsFinite(Single) IsFinite(Single) IsFinite(Single)

确定指定值是否为有限(零、次正规数或正规数)。Determines whether the specified value is finite (zero, subnormal or normal).

IsInfinity(Single) IsInfinity(Single) IsInfinity(Single) IsInfinity(Single)

返回一个值,该值指示指定数字是计算为负无穷大还是正无穷大。Returns a value indicating whether the specified number evaluates to negative or positive infinity.

IsNaN(Single) IsNaN(Single) IsNaN(Single) IsNaN(Single)

返回一个值,该值指示指定的值是否不为数字 (NaN)。Returns a value that indicates whether the specified value is not a number (NaN).

IsNegative(Single) IsNegative(Single) IsNegative(Single) IsNegative(Single)

确定指定值是否为负值。Determines whether the specified value is negative.

IsNegativeInfinity(Single) IsNegativeInfinity(Single) IsNegativeInfinity(Single) IsNegativeInfinity(Single)

返回一个值,通过该值指示指定数字是否计算为负无穷大。Returns a value indicating whether the specified number evaluates to negative infinity.

IsNormal(Single) IsNormal(Single) IsNormal(Single) IsNormal(Single)

确定指定值是否为正规数。Determines whether the specified value is normal.

IsPositiveInfinity(Single) IsPositiveInfinity(Single) IsPositiveInfinity(Single) IsPositiveInfinity(Single)

返回一个值,通过该值指示指定数字是否计算为正无穷大。Returns a value indicating whether the specified number evaluates to positive infinity.

IsSubnormal(Single) IsSubnormal(Single) IsSubnormal(Single) IsSubnormal(Single)

确定指定值是否是次正规数。Determines whether the specified value is subnormal.

Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider) Parse(String, NumberStyles, IFormatProvider)

将具有指定样式和区域性特定格式的数字的字符串表示形式转换为它的等效单精度浮点数。Converts the string representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent.

Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider) Parse(String, IFormatProvider)

将具有指定区域性特定格式的数字的字符串表示形式转换为它的等效单精度浮点数。Converts the string representation of a number in a specified culture-specific format to its single-precision floating-point number equivalent.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider) Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)
Parse(String) Parse(String) Parse(String) Parse(String)

将数字的字符串表示形式转换为它的等效单精度浮点数。Converts the string representation of a number to its single-precision floating-point number equivalent.

Parse(String, NumberStyles) Parse(String, NumberStyles) Parse(String, NumberStyles) Parse(String, NumberStyles)

将具有指定样式的数字的字符串表示形式转换为它的等效单精度浮点数。Converts the string representation of a number in a specified style to its single-precision floating-point number equivalent.

ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider)

使用指定的格式和区域性特定格式信息,将此实例的数值转换为它的等效字符串表示形式。Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.

ToString(String) ToString(String) ToString(String) ToString(String)

使用指定的格式,将此实例的数值转换为它的等效字符串表示形式。Converts the numeric value of this instance to its equivalent string representation, using the specified format.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

使用指定的区域性特定格式信息,将此实例的数值转换为它的等效字符串表示形式。Converts the numeric value of this instance to its equivalent string representation using the specified culture-specific format information.

ToString() ToString() ToString() ToString()

将此实例的数值转换为其等效的字符串表示形式。Converts the numeric value of this instance to its equivalent string representation.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single) TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Single)
TryParse(String, Single) TryParse(String, Single) TryParse(String, Single) TryParse(String, Single)

将数字的字符串表示形式转换为它的等效单精度浮点数。Converts the string representation of a number to its single-precision floating-point number equivalent. 一个指示转换是否成功的返回值。A return value indicates whether the conversion succeeded or failed.

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

将具有指定样式和区域性特定格式的数字的字符串表示形式转换为它的等效单精度浮点数。Converts the string representation of a number in a specified style and culture-specific format to its single-precision floating-point number equivalent. 一个指示转换是否成功的返回值。A return value indicates whether the conversion succeeded or failed.

操作员

Equality(Single, Single) Equality(Single, Single) Equality(Single, Single) Equality(Single, Single)

返回一个值,该值指示两个指定的 Single 值是否相等。Returns a value that indicates whether two specified Single values are equal.

GreaterThan(Single, Single) GreaterThan(Single, Single) GreaterThan(Single, Single) GreaterThan(Single, Single)

返回一个值,该值指示指定的 Single 值是否大于另一个指定的 Single 值。Returns a value that indicates whether a specified Single value is greater than another specified Single value.

GreaterThanOrEqual(Single, Single) GreaterThanOrEqual(Single, Single) GreaterThanOrEqual(Single, Single) GreaterThanOrEqual(Single, Single)

返回一个值,该值指示指定的 Single 值是否大于或等于另一个指定的 Single 值。Returns a value that indicates whether a specified Single value is greater than or equal to another specified Single value.

Inequality(Single, Single) Inequality(Single, Single) Inequality(Single, Single) Inequality(Single, Single)

返回一个值,该值指示两个指定的 Single 值是否不相等。Returns a value that indicates whether two specified Single values are not equal.

LessThan(Single, Single) LessThan(Single, Single) LessThan(Single, Single) LessThan(Single, Single)

返回一个值,该值指示指定的 Single 值是否小于另一个指定的 Single 值。Returns a value that indicates whether a specified Single value is less than another specified Single value.

LessThanOrEqual(Single, Single) LessThanOrEqual(Single, Single) LessThanOrEqual(Single, Single) LessThanOrEqual(Single, Single)

返回一个值,该值指示指定的 Single 值是否小于或等于另一个指定的 Single 值。Returns a value that indicates whether a specified Single value is less than or equal to another specified Single value.

显式界面实现

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

有关此成员的说明,请参见 ToBoolean(IFormatProvider)For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

有关此成员的说明,请参见 ToByte(IFormatProvider)For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

不支持此转换。This conversion is not supported. 尝试使用此方法将引发 InvalidCastExceptionAttempting to use this method throws an InvalidCastException.

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

不支持此转换。This conversion is not supported. 尝试使用此方法将引发 InvalidCastExceptionAttempting to use this method throws an InvalidCastException.

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

有关此成员的说明,请参见 ToDecimal(IFormatProvider)For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

有关此成员的说明,请参见 ToDouble(IFormatProvider)For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

有关此成员的说明,请参见 ToInt16(IFormatProvider)For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

有关此成员的说明,请参见 ToInt32(IFormatProvider)For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

有关此成员的说明,请参见 ToInt64(IFormatProvider)For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

有关此成员的说明,请参见 ToSByte(IFormatProvider)For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

有关此成员的说明,请参见 ToSingle(IFormatProvider)For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider)

有关此成员的说明,请参见 ToType(Type, IFormatProvider)For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

有关此成员的说明,请参见 ToUInt16(IFormatProvider)For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

有关此成员的说明,请参见 ToUInt32(IFormatProvider)For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

有关此成员的说明,请参见 ToUInt64(IFormatProvider)For a description of this member, see ToUInt64(IFormatProvider).

适用于

线程安全性

此类型的所有成员都是线程安全的。All members of this type are thread safe. 看似修改实例状态的成员实际上返回用新值初始化的新实例。Members that appear to modify instance state actually return a new instance initialized with the new value. 与任何其他类型一样,读取和写入包含此类型的实例的共享变量时,必须通过锁保护以保证线程安全。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.

另请参阅