共用方式為


ValueType 類別

定義

提供實值型別的基類。

public ref class ValueType abstract
public abstract class ValueType
[System.Serializable]
public abstract class ValueType
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class ValueType
type ValueType = class
[<System.Serializable>]
type ValueType = class
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ValueType = class
Public MustInherit Class ValueType
繼承
ValueType
衍生
屬性

備註

ValueType 會覆寫來自 Object 的虛擬方法,並針對實值型別使用更適當的實作。 另請參閱 Enum,其繼承自 ValueType

數據類型會分成實值型別和參考型別。 實值型別是堆疊配置的,或是在 結構中內嵌配置。 參考類型是堆積配置的。 參考和實值型別都是衍生自最終基類 Object。 如果實值型別的行為與對象類似,使實值型別看起來像在堆積上配置參考對象的包裝函式,而實值型別的值會複製到其中。 包裝函式會標示為讓系統知道它包含實值型別。 此程式稱為 Boxing,而反向進程稱為 Unboxing。 Boxing 和 unboxing 允許將任何類型視為 物件。

雖然 ValueType 是實值型別的隱含基類,但您無法建立直接繼承自 ValueType 的類別。 相反地,個別編譯程式會提供語言關鍵詞或建構(例如 C# 中的 struct 和 visual Basic 中的 Structure...End Structure),以支援建立實值型別。

除了做為 .NET Framework 中實值型別的基類之外,ValueType 結構通常不會直接用於程式代碼中。 不過,它可以做為方法呼叫中的參數,將可能自變數限制為實值型別,而不是所有物件,或允許方法處理數個不同的實值型別。 下列範例說明 ValueType 如何防止參考型別傳遞至方法。 它會定義名為 Utility 的類別,其中包含四種方法:IsNumeric,指出其自變數是否為數位;IsInteger,指出其自變數是否為整數;IsFloat,指出其自變數是否為浮點數;和 Compare,表示兩個數值之間的關聯性。 在每個案例中,方法參數的類型為 ValueType,而且無法將參考型別傳遞至方法。

using System;
using System.Numerics;

public class Utility
{
   public enum NumericRelationship {
      GreaterThan = 1, 
      EqualTo = 0,
      LessThan = -1
   };
   
   public static NumericRelationship Compare(ValueType value1, ValueType value2)
   {
      if (! IsNumeric(value1)) 
         throw new ArgumentException("value1 is not a number.");
      else if (! IsNumeric(value2))
         throw new ArgumentException("value2 is not a number.");

      // Use BigInteger as common integral type
      if (IsInteger(value1) && IsInteger(value2)) {
         BigInteger bigint1 = (BigInteger) value1;
         BigInteger bigint2 = (BigInteger) value2;
         return (NumericRelationship) BigInteger.Compare(bigint1, bigint2);
      }
      // At least one value is floating point; use Double.
      else {
         Double dbl1 = 0;
         Double dbl2 = 0;
         try {
            dbl1 = Convert.ToDouble(value1);
         }
         catch (OverflowException) {
            Console.WriteLine("value1 is outside the range of a Double.");
         }
         try {
            dbl2 = Convert.ToDouble(value2);
         }
         catch (OverflowException) {
            Console.WriteLine("value2 is outside the range of a Double.");
         }
         return (NumericRelationship) dbl1.CompareTo(dbl2);
      }
   }
   
   public static bool IsInteger(ValueType value)
   {         
      return (value is SByte || value is Int16 || value is Int32 
              || value is Int64 || value is Byte || value is UInt16  
              || value is UInt32 || value is UInt64 
              || value is BigInteger); 
   }

   public static bool IsFloat(ValueType value) 
   {         
      return (value is float || value is double || value is Decimal);
   }

   public static bool IsNumeric(ValueType value)
   {
      return (value is Byte ||
              value is Int16 ||
              value is Int32 ||
              value is Int64 ||
              value is SByte ||
              value is UInt16 ||
              value is UInt32 ||
              value is UInt64 ||
              value is BigInteger ||
              value is Decimal ||
              value is Double ||
              value is Single);
   }
}
open System
open System.Numerics

module Utility =
    type NumericRelationship =
        | GreaterThan = 1 
        | EqualTo = 0
        | LessThan = -1
   
    let isInteger (value: ValueType) =
        match value with
        | :? sbyte | :? int16 | :? int32 | :? int64 
        | :? byte | :? uint16  | :? uint32 
        | :? uint64 | :? bigint -> true
        | _ -> false

    let isFloat (value: ValueType) = 
        match value with
        | :? float32 | :? float | :? decimal -> true
        | _ -> false

    let tryToBigInt (value: ValueType) =
        match value with
        | :? sbyte as v -> bigint v |> Some
        | :? int16 as v -> bigint v |> Some
        | :? int32 as v -> bigint v |> Some
        | :? int64 as v -> bigint v |> Some
        | :? byte as v -> bigint v |> Some
        | :? uint16 as v -> bigint v |> Some
        | :? uint32 as v -> bigint v |> Some
        | :? uint64 as v -> bigint v |> Some
        | :? float32 as v -> bigint v |> Some
        | _ -> None

    let isNumeric (value: ValueType) =
        isInteger value || isFloat value

    let compare (value1: ValueType) (value2: ValueType) =
        if isNumeric value1 |> not then
            invalidArg "value1" "value1 is not a number."
        elif isNumeric value2 |> not then
            invalidArg "value2" "value2 is not a number."

        // Use BigInteger as common integral type
        match tryToBigInt value1, tryToBigInt value2 with
        | Some bigint1, Some bigint2 ->
            BigInteger.Compare(bigint1, bigint2) |> enum<NumericRelationship>

        // At least one value is floating point use Double.
        | _ ->
            let dbl1 = 
                try
                    Convert.ToDouble value1
                with
                | :? OverflowException ->
                    printfn "value1 is outside the range of a Double."
                    0.
                | _ -> 0.

            let dbl2 = 
                try
                    Convert.ToDouble value2
                with
                | :? OverflowException ->
                    printfn "value2 is outside the range of a Double."
                    0.
                | _ -> 0.
                
            dbl1.CompareTo dbl2 |> enum<NumericRelationship>
Imports System.Numerics

Public Class Utility
   Public Enum NumericRelationship As Integer
      GreaterThan = 1
      EqualTo = 0
      LessThan = -1
   End Enum
      
   Public Shared Function Compare(value1 As ValueType, value2 As ValueType) _
                                  As NumericRelationship
      If Not IsNumeric(value1) Then 
         Throw New ArgumentException("value1 is not a number.")
      Else If Not IsNumeric(value2) Then
         Throw New ArgumentException("value2 is not a number.")
      Else
         ' Use BigInteger as common integral type
         If isInteger(value1) And IsInteger(value2) Then
            Dim bigint1 As BigInteger = CType(value1, BigInteger)
            Dim bigInt2 As BigInteger = CType(value2, BigInteger)
            Return CType(BigInteger.Compare(bigint1, bigint2), NumericRelationship)
         ' At least one value is floating point; use Double.
         Else   
            Dim dbl1, dbl2 As Double
            Try
               dbl1 = CDbl(value1)
            Catch e As OverflowException
               Console.WriteLine("value1 is outside the range of a Double.")
            End Try
               
            Try
               dbl2 = CDbl(value2)
            Catch e As OverflowException
               Console.WriteLine("value2 is outside the range of a Double.")
            End Try
            Return CType(dbl1.CompareTo(dbl2), NumericRelationship)
         End If
      End If
   End Function
   
   Public Shared Function IsInteger(value As ValueType) As Boolean         
      Return (TypeOf value Is SByte Or TypeOf value Is Int16 Or TypeOf value Is Int32 _
                 Or TypeOf value Is Int64 Or TypeOf value Is Byte Or TypeOf value Is UInt16 _ 
                 Or TypeOf value Is UInt32 Or TypeOf value Is UInt64 _
                 Or TypeOf value Is BigInteger) 
   End Function

   Public Shared Function IsFloat(value As ValueType) As Boolean         
      Return (TypeOf value Is Single Or TypeOf value Is Double Or TypeOf value Is Decimal)
   End Function

   Public Shared Function IsNumeric(value As ValueType) As Boolean
      Return TypeOf value Is Byte OrElse
         TypeOf value Is Int16 OrElse
         TypeOf value Is Int32 OrElse
         TypeOf value Is Int64 OrElse
         TypeOf value Is SByte OrElse
         TypeOf value Is UInt16 OrElse
         TypeOf value Is UInt32 OrElse
         TypeOf value Is UInt64 OrElse
         TypeOf value Is BigInteger OrElse
         TypeOf value Is Decimal OrElse
         TypeOf value Is Double OrElse
         TypeOf value Is Single
   End Function
End Class

下列範例說明對 Utility 類別方法的呼叫。

public class Example
{
   public static void Main()
   {
      Console.WriteLine(Utility.IsNumeric(12));
      Console.WriteLine(Utility.IsNumeric(true));
      Console.WriteLine(Utility.IsNumeric('c'));
      Console.WriteLine(Utility.IsNumeric(new DateTime(2012, 1, 1)));
      Console.WriteLine(Utility.IsInteger(12.2));
      Console.WriteLine(Utility.IsInteger(123456789));
      Console.WriteLine(Utility.IsFloat(true));
      Console.WriteLine(Utility.IsFloat(12.2));
      Console.WriteLine(Utility.IsFloat(12));
      Console.WriteLine("{0} {1} {2}", 12.1, Utility.Compare(12.1, 12), 12);
   }
}
// The example displays the following output:
//       True
//       False
//       False
//       False
//       False
//       True
//       False
//       True
//       False
//       12.1 GreaterThan 12
printfn $"{Utility.isNumeric 12}"
printfn $"{Utility.isNumeric true}"
printfn $"{Utility.isNumeric 'c'}"
printfn $"{Utility.isNumeric (DateTime(2012, 1, 1))}"
printfn $"{Utility.isInteger 12.2}"
printfn $"{Utility.isInteger 123456789}"
printfn $"{Utility.isFloat true}"
printfn $"{Utility.isFloat 12.2}"
printfn $"{Utility.isFloat 12}"
printfn $"{12.1} {Utility.compare 12.1 12} {12}"
// The example displays the following output:
//       True
//       False
//       False
//       False
//       False
//       True
//       False
//       True
//       False
//       12.1 GreaterThan 12
Module Example
   Public Sub Main()
      Console.WriteLine(Utility.IsNumeric(12))
      Console.WriteLine(Utility.IsNumeric(True))
      Console.WriteLine(Utility.IsNumeric("c"c))
      Console.WriteLine(Utility.IsNumeric(#01/01/2012#))
      Console.WriteLine(Utility.IsInteger(12.2))
      Console.WriteLine(Utility.IsInteger(123456789))
      Console.WriteLine(Utility.IsFloat(True))
      Console.WriteLine(Utility.IsFloat(12.2))
      Console.WriteLine(Utility.IsFloat(12))
      Console.WriteLine("{0} {1} {2}", 12.1, Utility.Compare(12.1, 12), 12)
   End Sub
End Module
' The example displays the following output:
'       True
'       False
'       False
'       False
'       False
'       True
'       False
'       True
'       False
'       12.1 GreaterThan 12

建構函式

ValueType()

初始化 ValueType 類別的新實例。

方法

Equals(Object)

指出這個實例和指定的物件是否相等。

GetHashCode()

傳回這個實例的哈希碼。

GetType()

取得目前實例的 Type

(繼承來源 Object)
MemberwiseClone()

建立目前 Object的淺層複本。

(繼承來源 Object)
ToString()

傳回這個實例的完整型別名稱。

適用於

另請參閱