ValueType 类

定义

为值类型提供基类。Provides the base class for value types.

public ref class ValueType abstract
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public abstract class ValueType
type ValueType = class
Public MustInherit Class ValueType
继承
ValueType
派生
属性

注解

ValueType 会重写 Object 中的虚拟方法,并具有更合适的值类型实现。ValueType overrides the virtual methods from Object with more appropriate implementations for value types. 另请参阅 Enum,后者继承自 @no__t。See also Enum, which inherits from ValueType.

数据类型被分隔为值类型和引用类型。Data types are separated into value types and reference types. 值类型要么是堆栈分配,要么在结构中以内联方式分配。Value types are either stack-allocated or allocated inline in a structure. 引用类型为堆分配。Reference types are heap-allocated. 引用类型和值类型都派生自最终基类 ObjectBoth reference and value types are derived from the ultimate base class Object. 如果需要值类型的行为与对象类似,则会在堆上分配值类型类似于引用对象的包装,并将值类型的值复制到其中。In cases where it is necessary for a value type to behave like an object, a wrapper that makes the value type look like a reference object is allocated on the heap, and the value type's value is copied into it. 包装已标记,因此系统知道它包含值类型。The wrapper is marked so the system knows that it contains a value type. 此过程称为装箱,相反的过程称为取消装箱。This process is known as boxing, and the reverse process is known as unboxing. 装箱和取消装箱允许任何类型被视为对象。Boxing and unboxing allow any type to be treated as an object.

尽管 @no__t 是值类型的隐式基类,但无法创建直接从 @no__t 继承的类。Although ValueType is the implicit base class for value types, you cannot create a class that inherits from ValueType directly. 相反,单个编译器提供语言关键字或构造(例如 struct in C#和 Structure ... End StructureInstead, individual compilers provide a language keyword or construct (such as struct in C# and StructureEnd Structure 在 Visual Basic)支持创建值类型。in Visual Basic) to support the creation of value types.

除了作为 .NET Framework 中值类型的基类,通常不在代码中直接使用 @no__t 的结构。Aside from serving as the base class for value types in the .NET Framework, the ValueType structure is generally not used directly in code. 但是,它可用作方法调用中的参数,以将可能的自变量限制为值类型而不是所有对象,或者允许方法处理许多不同的值类型。However, it can be used as a parameter in method calls to restrict possible arguments to value types instead of all objects, or to permit a method to handle a number of different value types. 下面的示例说明了 ValueType 如何防止将引用类型传递给方法。The following example illustrates how ValueType prevents reference types from being passed to methods. 它定义了一个名为 Utility 的类,其中包含四个方法: IsNumeric,指示其参数是否为数字;IsInteger,指示其参数是否为整数;IsFloat,指示其参数是否为浮点数;和 Compare,它指示两个数值之间的关系。It defines a class named Utility that contains four methods: IsNumeric, which indicates whether its argument is a number; IsInteger, which indicates whether its argument is an integer; IsFloat, which indicates whether its argument is a floating-point number; and Compare, which indicates the relationship between two numeric values. 在每种情况下,方法参数的类型均为 ValueType,并且不会将引用类型传递给方法。In each case, the method parameters are of type ValueType, and reference types are prevented from being passed to the methods.

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);
   }
}
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

下面的示例演示对 @no__t 类的方法的调用。The following example illustrates calls to the methods of the Utility class.

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
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 类的新实例。Initializes a new instance of the ValueType class.

方法

Equals(Object)

指示此实例与指定对象是否相等。Indicates whether this instance and a specified object are equal.

GetHashCode()

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

GetType()

获取当前实例的 TypeGets the Type of the current instance.

(继承自 Object)
MemberwiseClone()

创建当前 Object 的浅表副本。Creates a shallow copy of the current Object.

(继承自 Object)
ToString()

返回此实例的完全限定类型名称。Returns the fully qualified type name of this instance.

适用于

另请参阅