System.Single 結構

2025-06-17

本文提供此 API 參考文件的補充備註。

Single 實值類型代表單精度 32 位數位，其值範圍從負 3.402823e38 到正 3.402823e38，以及正數或負零、PositiveInfinity、NegativeInfinity，而不是數位（NaN）。它旨在表示極其大的數值（例如行星或星系之間的距離）或極其小的數值（例如公斤中物質的分子質量），而且通常不精確（例如從地球到另一個太陽系的距離）。 Single 類型符合二進位浮點算術的 IEC 60559：1989（IEEE 754）標準。

System.Single 提供方法來比較此類型的實例、將實例的值轉換為其字串表示，以及將數位的字串表示轉換為此類型的實例。如需格式規格代碼如何控制實值型別字串表示的資訊，請參閱格式化類型、標準數值格式字串，以及自定義數值格式字元串。

浮點表示法和精確度

Single 數據類型會以 32 位二進位格式儲存單精度浮點值，如下表所示：

部分	位元
Significand 或 mantissa	0-22
指數	23-30
符號（0 = 正數，1 = 負數）	31

就像小數分數無法精確表示某些小數值（例如 1/3 或 Math.PI），二進位分數無法代表某些小數值。例如，2/10 可以精確地表示為小數 .2，並表示為二進位分數 .0011111001001100，其中模式 "1100" 無限重複。在此情況下，浮點值會提供其所代表數位的不精確表示。對原始浮點值執行額外的數學運算，通常會增加其缺乏精確度。例如，如果您比較將 .3 乘以 10 的結果，並將 .3 加到 .3 九次，您會看到加法會產生較不精確的結果，因為它牽涉到比乘法多八個運算。請注意，唯有在您使用 “R” Single來顯示兩個值時，這個差異才會顯露出來。必要時，會顯示 Single 類型所支援的所有 9 位數的精確度。

using System;

public class Example12
{
    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:           {result1:R}");
        Console.WriteLine($".2 Added 10 times: {result2:R}");
    }
}
// The example displays the following output:
//       .2 * 10:           2
//       .2 Added 10 times: 2.00000024

let value = 0.2f
let result1 = value * 10f
let mutable result2 = 0f
for _ = 1 to 10 do
    result2 <- result2 + value

printfn $".2 * 10:           {result1:R}"
printfn $".2 Added 10 times: {result2:R}"
// The example displays the following output:
//       .2 * 10:           2
//       .2 Added 10 times: 2.00000024

Module Example13
    Public Sub Main()
        Dim value As Single = 0.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

由於某些數位不能完全表示為小數二進位值，浮點數只能近似實數。

所有浮點數都有有限的有效位數，這也決定浮點值對實數的近似程度。 Single 值最多可有 7 個小數位數的精確度，但內部最多可維護 9 位數。這表示某些浮點運算可能缺少變更浮點值的精確度。下列範例定義了一個大型單精度浮點數，然後將 Single.Epsilon 和一千兆的乘積加入其中。不過，產品太小，無法修改原始浮點值。其最小有效位數為千分之一，而產品中最有效位數為 10^-30。

using System;

public class Example13
{
    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

open System

let value = 123.456f
let additional = Single.Epsilon * 1e15f
printfn $"{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

浮點數的有限精度會產生數個影響：

針對特定有效位數，看似相等的兩個浮點數可能不會比較相等，因為最低有效位數不同。在下列範例中，一連串的數字會加在一起，其總和與預期總和進行比較。雖然這兩個值似乎相同，但對 Equals 方法的呼叫表示它們不是。

using System;

public class Example9
{
    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 ({total}) does not equal the 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).

let values = [| 10.01f; 2.88f; 2.88f; 2.88f; 9f |]
let result = 27.65f
let mutable total = 0f
for value in values do
    total <- total + value

if total.Equals result then
    printfn "The sum of the values equals the total."
else
    printfn "The sum of the values ({total}) does not equal the 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 Example10
    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 值的所有有效位數，則很明顯，由於加法作業期間精確度損失，這兩個值並不相等。在此情況下，您可以藉由呼叫 Math.Round(Double, Int32) 方法，將 Single 值四捨五入至所需的精確度，再執行比較，來解決此問題。

如果使用十進位數，使用浮點數的數學或比較運算可能不會產生相同的結果，因為二進位浮點數可能不等於十進位數。上一個範例透過將 .3 乘以 10，然後將 .3 加上 .3 共九次來說明這一點。

當具有小數值的數值運算精確度很重要時，請使用 Decimal 類型，而不是 Single 類型。當整數值的數字運算精確度超出 Int64 或 UInt64 類型的範圍時，請使用 BigInteger 類型。

如果涉及浮點數，值可能不會來回。當某項操作將原始浮點數轉換成另一種形式，反向運算又將轉換後的形式轉換回浮點數，並且最終得到的浮點數等於原始浮點數，這樣的值稱為往返。來回行程可能會失敗，因為轉換中遺失或變更了一或多個最小有效位數。

在下列範例中，三個 Single 值會轉換成字串，並儲存在檔案中。如果您在 .NET Framework 上執行此範例，即使值看起來相同，還原的值不等於原始值。（此問題在 .NET 中已解決，讓數值可以正確往返。）

StreamWriter sw = new(@"./Singles.dat");
float[] 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();

float[] restoredValues = new float[values.Length];
StreamReader sr = new(@"./Singles.dat");
string temp = sr.ReadToEnd();
string[] tempStrings = temp.Split('|');
for (int ctr = 0; ctr < tempStrings.Length; ctr++)
    restoredValues[ctr] = float.Parse(tempStrings[ctr]);

for (int ctr = 0; ctr < values.Length; ctr++)
    Console.WriteLine($"{values[ctr]} {(values[ctr].Equals(restoredValues[ctr]) ? "=" : "<>")} {restoredValues[ctr]}");

// The example displays the following output:
//       2.882883 <> 2.882883
//       0.3333333 <> 0.3333333
//       3.141593 <> 3.141593

open System
open System.IO

let values = [| 3.2f / 1.11f; 1f / 3f; MathF.PI |]

do
    use sw = new StreamWriter(@".\Singles.dat")
    for i = 0 to values.Length - 1 do
        sw.Write(string values[i])
        if i <> values.Length - 1 then
            sw.Write "|"

let restoredValues =
    use sr = new StreamReader(@".\Singles.dat")
    sr.ReadToEnd().Split '|'
    |> Array.map Single.Parse

for i = 0 to values.Length - 1 do
    printfn $"""{values[i]} {if values[i].Equals restoredValues[i] then "=" else "<>"} {restoredValues[i]}"""
                    
// The example displays the following output:
//       2.882883 <> 2.882883
//       0.3333333 <> 0.3333333
//       3.141593 <> 3.141593

Imports System.IO

Module Example11
    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

如果您以 .NET Framework 為目標，可以使用 "G9" 標準數值格式字串進行成功的來回轉換，以保留 Single 值的完整精確度。

Single 的數值精度低於 Double 的數值。轉換成看似相等的 Single 值的 Double 值，通常不等於 Double 值，因為精確度的差異。在下列範例中，相同的除法作業結果會指派給 Double 值和 Single 值。將 Single 值轉換成 Double之後，兩個值的比較會顯示它們不相等。

using System;

public class Example9
{
    public static void Main()
    {
        Double value1 = 1 / 3.0;
        Single sValue2 = 1 / 3.0f;
        Double value2 = (Double)sValue2;
        Console.WriteLine($"{value1:R} = {value2:R}: {value1.Equals(value2)}");
    }
}
// The example displays the following output:
//        0.33333333333333331 = 0.3333333432674408: False

open System

let value1 = 1. / 3.
let sValue2 = 1f /3f

let value2 = double sValue2
printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
// The example displays the following output:
//        0.33333333333333331 = 0.3333333432674408: False

Module Example10
    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 方法，讓兩個值具有相同的有效位數。

進行相等性測試

若要視為相等，兩個 Single 值必須代表相同的值。不過，由於數值之間精度的差異，或因為一個或兩個數值失去了精度，預期完全相同的浮點數值通常會因其最不重要的位數差異而不相等。因此，呼叫 Equals 方法來判斷兩個值是否相等，或呼叫 CompareTo 方法來判斷兩個 Single 值之間的關聯性，通常會產生非預期的結果。這在下列範例中很明顯，其中兩個看似相等的 Single 值結果不相等，因為第一個值有 7 位有效數字，而第二個值則有 9 位。

using System;

public class Example
{
   public static void Main()
   {
      float value1 = .3333333f;
      float value2 = 1.0f/3;
      Console.WriteLine($"{value1:R} = {value2:R}: {value1.Equals(value2)}");
   }
}
// The example displays the following output:
//        0.3333333 = 0.333333343: False

let value1 = 0.3333333f
let value2 = 1f / 3f
printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
// The example displays the following output:
//        0.3333333 = 0.333333343: False

Module Example1
    Public Sub Main()
        Dim value1 As Single = 0.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

遵循不同程式路徑且以不同方式處理的計算值經常會不相等。在下列範例中，一個 Single 值是平方，然後計算平方根來還原原始值。第二個 Single 先乘以 3.51，然後平方，之後將結果的平方根除以 3.51，以還原為原始的第二個 Single 值。雖然這兩個值看起來完全相同，但對 Equals(Single) 方法的呼叫表示它們不相等。使用「G9」標準格式字串來傳回結果字串，以顯示每個 Single 值的所有有效位數，後續顯示第二個值比第一個值小 0.0000000000001。

using System;

public class Example1
{
    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($"{value1} = {value2}: {value1.Equals(value2)}");
        Console.WriteLine();
        Console.WriteLine($"{value1:G9} = {value2:G9}");
    }
}
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389

let value1 = 
    10.201438f ** 2f
    |> sqrt

let value2 =
   ((value1 * 3.51f) ** 2f |> sqrt) / 3.51f

printfn $"{value1} = {value2}: {value1.Equals value2}\n" 
printfn $"{value1:G9} = {value2:G9}"
// The example displays the following output:
//       10.20144 = 10.20144: False
//       
//       10.201438 = 10.2014389

Module Example2
    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

如果遺失精確度可能會影響比較的結果，您可以使用下列技術，而不是呼叫 Equals 或 CompareTo 方法：

呼叫 Math.Round 方法，以確保這兩個值具有相同的精度。下列範例會修改先前的範例，以使用此方法，讓兩個小數值相等。

using System;

public class Example2
{
    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($"{value1:R} = {value2:R}: {value1.Equals(value2)}");
    }
}
// The example displays the following output:
//        0.3333333 = 0.3333333: True

open System

let value1 = 0.3333333f
let value2 = 1f / 3f
let precision = 7
let value1r = Math.Round(float value1, precision) |> float32
let value2r = Math.Round(float value2, precision) |> float32
printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
// The example displays the following output:
//        0.3333333 = 0.3333333: True

Module Example3
    Public Sub Main()
        Dim value1 As Single = 0.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

精確度問題仍適用於中間點值的四捨五入。如需詳細資訊，請參閱 Math.Round(Double, Int32, MidpointRounding) 方法。

測試大約相等，而不要測試完全相等。此技術要求您定義一個絕對數量，兩個值可以相差此數量但仍視為相等，或者定義一個相對數量，其中較小的值可以與較大的值有所差異。

警告

當測試是否相等時，Single.Epsilon 有時會當做兩個 Single 值之間距離的絕對量值。不過，Single.Epsilon 測量可以加到或減去其值為零的 Single 的最小可能值。對於大部分的正負 Single 值，Single.Epsilon 的值太小而無法偵測。因此，除了零值，我們不建議用於相等性測試。

下列範例會使用後者方法來定義 IsApproximatelyEqual 方法，以測試兩個值之間的相對差異。它也會對比呼叫 IsApproximatelyEqual 方法和 Equals(Single) 方法的結果。

using System;

public class Example3
{
    public static void Main()
    {
        float one1 = .1f * 10;
        float one2 = 0f;
        for (int ctr = 1; ctr <= 10; ctr++)
            one2 += .1f;

        Console.WriteLine($"{one1:R} = {one2:R}: {one1.Equals(one2)}");
        Console.WriteLine($"{one1:R} is approximately equal to {one2:R}: " +
            $"{IsApproximatelyEqual(one1, one2, .000001f)}");
        
        float negativeOne1 = -1 * one1;
        float negativeOne2 = -1 * one2;

        Console.WriteLine($"{negativeOne1:R} = {negativeOne2:R}: {negativeOne1.Equals(negativeOne2)}");
        Console.WriteLine($"{negativeOne1:R} is approximately equal to {negativeOne2:R}: " +
            $"{IsApproximatelyEqual(negativeOne1, negativeOne2, .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
//       -1 is approximately equal to -1.00000012: True

open System

let isApproximatelyEqual value1 value2 epsilon =
    // If they are equal anyway, just return True.
    if value1.Equals value2 then 
        true
    // Handle NaN, Infinity.
    elif Single.IsInfinity value1 || Single.IsNaN value1 then
        value1.Equals value2
    elif Single.IsInfinity value2 || Single.IsNaN value2 then
        value1.Equals value2
    else
        // Handle zero to avoid division by zero
        let divisor = max value1 value2
        let divisor = 
            if divisor.Equals 0 then
                min value1 value2
            else divisor
        abs (value1 - value2) / divisor <= epsilon           


let one1 = 0.1f * 10f
let mutable one2 = 0f
for _ = 1 to 10 do
   one2 <- one2 + 0.1f

printfn $"{one1:R} = {one2:R}: {one1.Equals one2}"
printfn $"{one1:R} is approximately equal to {one2:R}: {isApproximatelyEqual one1 one2 0.000001f}" 
// The example displays the following output:
//       1 = 1.00000012: False
//       1 is approximately equal to 1.00000012: True

Module Example4
    Public Sub Main()
        Dim one1 As Single = 0.1 * 10
        Dim one2 As Single = 0
        For ctr As Integer = 1 To 10
            one2 += CSng(0.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, 0.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)
        ElseIf Single.IsInfinity(value2) Or Single.IsNaN(value2) Then
            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

浮點值和例外狀況

具有浮點值的作業不會擲回例外狀況，與整數類型的作業不同，這會在除以零或溢位等不合法的作業時擲回例外狀況。相反地，在這些情況下，浮點運算的結果為零、正無限大、負無限大，或不是數位（NaN）：

如果浮點運算的結果對目的格式而言太小，則結果為零。當兩個非常小的浮點數相乘時，就會發生這種情況，如下列範例所示。

using System;

public class Example6
{
    public static void Main()
    {
        float value1 = 1.163287e-36f;
        float value2 = 9.164234e-25f;
        float result = value1 * value2;
        Console.WriteLine($"{value1} * {value2} = {result}");
        Console.WriteLine($"{result} = 0: {result.Equals(0.0f)}");
    }
}
// The example displays the following output:
//       1.163287E-36 * 9.164234E-25 = 0
//       0 = 0: True

let value1 = 1.163287e-36f
let value2 = 9.164234e-25f
let result = value1 * value2
printfn $"{value1} * {value2} = {result}"
printfn $"{result} = 0: {result.Equals(0f)}"
// The example displays the following output:
//       1.163287E-36 * 9.164234E-25 = 0
//       0 = 0: True

Module Example7
    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

如果浮點運算的結果大於目的格式的範圍，則依據結果的正負號，作業的結果會是 PositiveInfinity 或 NegativeInfinity。 Single.MaxValue 溢位作業的結果是 PositiveInfinity，而溢位 Single.MinValue 的作業結果 NegativeInfinity，如下列範例所示。

using System;

public class Example7
{
    public static void Main()
    {
        float value1 = 3.065e35f;
        float value2 = 6.9375e32f;
        float result = value1 * value2;
        Console.WriteLine($"PositiveInfinity: {Single.IsPositiveInfinity(result)}");
        Console.WriteLine($"NegativeInfinity: {Single.IsNegativeInfinity(result)}");
        Console.WriteLine();

        value1 = -value1;
        result = value1 * value2;
        Console.WriteLine($"PositiveInfinity: {Single.IsPositiveInfinity(result)}");
        Console.WriteLine($"NegativeInfinity: {Single.IsNegativeInfinity(result)}");
    }
}

// The example displays the following output:
//       PositiveInfinity: True
//       NegativeInfinity: False
//       
//       PositiveInfinity: False
//       NegativeInfinity: True

open System

let value1 = 3.065e35f
let value2 = 6.9375e32f
let result = value1 * value2
printfn $"PositiveInfinity: {Single.IsPositiveInfinity result}" 
printfn $"NegativeInfinity: {Single.IsNegativeInfinity result}\n"

let value3 = -value1
let result2 = value3 * value2
printfn $"PositiveInfinity: {Single.IsPositiveInfinity result}" 
printfn $"NegativeInfinity: {Single.IsNegativeInfinity result}" 

// The example displays the following output:
//       PositiveInfinity: True
//       NegativeInfinity: False
//       
//       PositiveInfinity: False
//       NegativeInfinity: True

Module Example8
    Public Sub Main()
        Dim value1 As Single = 3.065E+35
        Dim value2 As Single = 6.9375E+32
        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 則由負的被除數除以零產生。

如果浮點運算無效，作業的結果會 NaN。例如，NaN 是由下列操作得出的結果：
- 以零作為被除數進行除以零的運算。請注意，其他除以零的情況結果為PositiveInfinity或NegativeInfinity。
- 任何具有無效輸入的浮點運算。例如，嘗試尋找負值的平方根會傳回 NaN。
- 任何具有其值為Single.NaN的引數的運算。

類型轉換

Single 結構未定義任何明確或隱含轉換運算符;相反地，編譯程式會實作轉換。

下表列出其他原始數字型別的值可能轉換為 Single 值，並說明轉換是寬化還是窄化，以及生成的 Single 是否可能擁有比原始值更低的精度。

轉換自	擴大/縮小	可能损失精度
Byte	擴大	否
Decimal	擴大請注意，C# 需要轉換運算元。	是的。 Decimal 支援 29 個小數位數的有效位數；Single 支援 9。
Double	縮小;超出範圍的值會轉換成 Double.NegativeInfinity 或 Double.PositiveInfinity。	是的。 Double 支援 17 小數位上的精度；Single 支援 9 小數位上的精度。
Int16	擴大	否
Int32	擴大	是的。 Int32 支援 10 個小數位數; Single 支援 9 個小數位數。
Int64	擴大	是的。 Int64 支援 19 個小數位數的有效位數；Single 支援 9 個小數位數的有效位數。
SByte	擴大	否
UInt16	擴大	否
UInt32	擴大	是的。 UInt32 支援 10 個小數位數; Single 支援 9 個小數位數。
UInt64	擴大	是的。 Int64 支援 20 個有效位數；Single 支援 9。

下列範例會將其他基本數值類型的最小值或最大值轉換為 Single 值。

using System;

public class Example4
{
    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($"{value} ({value.GetType().Name}) --> {sngValue:R} ({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)

open System

let values: obj list = 
    [ 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 ]

for value in values do
    let sngValue = 
        match value with
        | :? byte as v -> float32 v
        | :? decimal as v -> float32 v
        | :? double as v -> float32 v
        | :? int16 as v -> float32 v
        | :? int as v -> float32 v
        | :? int64 as v -> float32 v
        | :? int8 as v -> float32 v
        | :? uint16 as v -> float32 v
        | :? uint as v -> float32 v
        | :? uint64 as v -> float32 v
        | _ -> raise (NotImplementedException "Unknown Type")
    printfn $"{value} ({value.GetType().Name}) --> {sngValue:R} ({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 Example5
    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.NaN、Double.PositiveInfinity和 Double.NegativeInfinity 分別轉換成 Single.NaN、Single.PositiveInfinity和 Single.NegativeInfinity。

請注意，將某些數值型別的值轉換成 Single 值，可能涉及精確度遺失。如範例所示，將 Decimal、Double、Int32、Int64、UInt32和 UInt64 值轉換成 Single 值時，可能會有精度的損失。

將 Single 值轉換成 Double 是擴大轉換。如果 Double 類型沒有 Single 值的精確表示法，轉換可能會導致精確度遺失。

Single 值轉換成 Double 以外的任何基本數值數據類型的值是縮小轉換，而且需要轉換運算符（C#）或轉換方法（在 Visual Basic 中）。目標數據類型範圍以外的值，這些值是由目標類型的 MinValue 和 MaxValue 屬性所定義，其行為如下表所示。

目標類型	結果
任何整數類型	如果轉換發生在已檢查的內容中，則為 OverflowException 例外狀況。如果轉換發生在未核取的內容中（C# 中的預設值），轉換作業會成功，但值溢位。
Decimal	出現了OverflowException例外情況，

此外，Single.NaN、Single.PositiveInfinity和 Single.NegativeInfinity 會擲回 OverflowException，以便在已檢查的上下文中轉換成整數，但這些值在未檢查的上下文中轉換成整數時會溢位。若要轉換成 Decimal，它們一律會拋出 OverflowException。若要轉換成 Double，它們分別轉換成 Double.NaN、Double.PositiveInfinity和 Double.NegativeInfinity。

請注意，精確度遺失可能會導致將 Single 值轉換成另一個數值類型。在轉換非整數 Single 值的情況下，根據範例所示的輸出，當 Single 值在 Visual Basic 中被四捨五入，或在 C# 和 F# 中被截斷時，小數部分會遺失。若要轉換成 Decimal 值，Single 值在目標數據類型中可能沒有精確的表示法。

下列範例會將一些 Single 值轉換成數個其他數值類型。這些轉換發生在 Visual Basic 的已核取內容中（預設值）、C# 中（因為已核取關鍵詞），以及 F# 中的轉換（因為 open Checked 語句）。範例的輸出顯示在已檢查和未檢查環境中進行轉換的結果。您可以在 Visual Basic 中未核取的內容中執行轉換，方法是使用 /removeintchecks+ 編譯程式參數、在 C# 中將 checked 語句批注化，並在 F# 中將 open Checked 語句批注化。

using System;

public class Example5
{
    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($"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to Int64.");
                }
                try
                {
                    UInt64 ulValue = (ulong)value;
                    Console.WriteLine($"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to UInt64.");
                }
                try
                {
                    Decimal dValue = (decimal)value;
                    Console.WriteLine($"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})");
                }
                catch (OverflowException)
                {
                    Console.WriteLine($"Unable to convert {value} to Decimal.");
                }

                Double dblValue = value;
                Console.WriteLine($"{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)

open System
open Checked

let values = 
    [ Single.MinValue; -67890.1234f; -12345.6789f
      12345.6789f; 67890.1234f; Single.MaxValue
      Single.NaN; Single.PositiveInfinity
      Single.NegativeInfinity ]

for value in values do
    try
        let lValue = int64 value
        printfn $"{value} ({value.GetType().Name}) --> {lValue} (0x{lValue:X16}) ({lValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Int64."
    try
        let ulValue = uint64 value
        printfn $"{value} ({value.GetType().Name}) --> {ulValue} (0x{ulValue:X16}) ({ulValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to UInt64."
    try
        let dValue = decimal value
        printfn $"{value} ({value.GetType().Name}) --> {dValue} ({dValue.GetType().Name})"
    with :? OverflowException ->
        printfn $"Unable to convert {value} to Decimal."

    let dblValue = double value
    printfn $"{value} ({value.GetType().Name}) --> {dblValue} ({dblValue.GetType().Name})\n"
// 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 Example6
    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 中的型別轉換和類型轉換資料表。

浮點功能

Single 結構和相關類型提供方法來執行下列作業類別：

的值比較。您可以呼叫 Equals 方法來判斷兩個 Single 值是否相等，或判斷兩個值之間的關聯性 CompareTo 方法。

Single 結構也支援一組完整的比較運算符。例如，您可以測試是否相等或不等，或判斷某個值是否大於或等於另一個值。如果其中一個運算元是 Double，在執行比較之前，Single 值會被轉換成 Double。如果其中一個運算元是整數型別，則會在執行比較之前，先轉換為 Single。雖然這些是擴展型轉換，但它們可能涉及精度的丟失。

警告

由於精確度的差異，您預期相等的兩個 Single 值可能會不相等，這會影響比較的結果。如需比較兩個值的詳細資訊，請參閱 Single 一節。

您也可以呼叫 IsNaN、IsInfinity、IsPositiveInfinity和 IsNegativeInfinity 方法來測試這些特殊值。
數學運算。一般算術運算，例如加法、減法、乘法和除法，都是由語言編譯程式和 Common Intermediate Language （CIL）指令實作，而不是由 Single 方法實作。如果數學運算中的其他作數是 Double，則 Single 在執行作業之前會轉換成 Double，而作業的結果也是 Double 值。如果另一個作數是整數型別，則會在執行作業之前轉換為 Single，而作業的結果也是 Single 值。

您可以在 static 類別中呼叫 Shared （visual Basic 中的System.Math）方法來執行其他數學運算。其中包括常用於算術的其他方法（例如 Math.Abs、Math.Sign和 Math.Sqrt）、幾何（例如 Math.Cos 和 Math.Sin），以及微積分（例如 Math.Log）。在所有情況下，Single 值都會轉換成 Double。

您也可以操作 Single 值中的單個位元。 BitConverter.GetBytes(Single) 方法會將其位元模式返回到位元組數列中。將位元組陣列傳遞至 BitConverter.ToInt32 方法，您也可以在 32 位整數中保留 Single 值的位模式。
四捨五入。四捨五入通常用來作為減少浮點表示和精確度問題所造成值差異影響的技術。您可以通過調用 Single 方法來舍入 Math.Round 值。不過，請注意，在呼叫方法之前，Single 值會轉換成 Double，而且轉換可能牽涉到精確度的遺失。
格式化. 您可以呼叫 Single 方法或使用 ToString 功能，將值轉換成其字串表示法。為了瞭解格式字串如何控制浮點值的字串表示，請參閱標準數值格式字串和自訂數值格式字串。
解析字串。您可以呼叫 Single 或 Parse 方法，將浮點值的字串表示轉換成 TryParse 值。如果剖析作業失敗，Parse 方法會擲回例外狀況，而 TryParse 方法會傳回 false。

型別轉換. Single 結構提供 IConvertible 介面的明確介面實作，可支援任何兩個標準 .NET 數據類型之間的轉換。語言編譯程式也支援所有其他標準數值類型的隱含轉換，但 Double 轉換成 Single 值除外。將 Double 以外的任何標準數值型別值轉換成 Single 是擴大轉換，不需要使用轉型運算符或轉換方法。

不過，32 位和64位整數值的轉換可能會涉及精確度的遺失。下表列出 32 位、64 位和 Double 類型的精確度差異：

類型	最大精確度（以十進位數為單位）	内部精度（以小數位表示）
Double	15	17
Int32 和 UInt32	10	10
Int64 和 UInt64	19	19
Single	7	9

精確度問題最常影響的是 Single 值在轉換成 Double 值的過程中。在下列範例中，相同除法運算所產生的兩個值不相等，因為其中一個值是轉換成 Double的單精度浮點值。

using System;

public class Example8
{
    public static void Main()
    {
        Double value1 = 1 / 3.0;
        Single sValue2 = 1 / 3.0f;
        Double value2 = (Double)sValue2;
        Console.WriteLine($"{value1:R} = {value2:R}: {value1.Equals(value2)}");
    }
}
// The example displays the following output:
//        0.33333333333333331 = 0.3333333432674408: False

let value1 = 1. / 3.
let sValue2 = 1f / 3f
let value2 = double sValue2
printfn $"{value1:R} = {value2:R}: {value1.Equals value2}"
// The example displays the following output:
//        0.33333333333333331 = 0.3333333432674408: False

Module Example9
    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

共用方式為