ValueType 类

参考

定义

命名空间:: System

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

Source:: ValueType.cs

Source:: ValueType.cs

Source:: ValueType.cs

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

提供值类型的基类。

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

继承: Object
ValueType

派生: _GUID

Accessibility.__MIDL_IWinTypes_0009

Accessibility._RemotableHandle

IStream

ISymUnmanagedBinder

更多…

属性: SerializableAttribute ComVisibleAttribute

注解

ValueType 使用更适当的实现替代 Object 的虚拟方法。另请参阅 Enum，它继承自 ValueType。

数据类型分为值类型和引用类型。值类型在结构中为堆栈分配或内联分配。引用类型是堆分配的。引用和值类型都派生自最终基类 Object。如果值类型的行为类似于对象，使值类型看起来像在堆上分配引用对象的包装器，并将值类型的值复制到其中。包装器被标记，以便系统知道它包含值类型。此过程称为装箱，反向进程称为取消装箱。装箱和取消装箱允许将任何类型视为对象。

尽管 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()	返回此实例的完全限定类型名称。

适用于

另请参阅

Object
Enum

通过

ValueType 类

定义

注解

构造函数

方法

适用于

另请参阅

其他资源