This documentation is archived and is not being maintained.

ValueType Class

Updated: October 2010

Provides the base class for value types.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)

public abstract class ValueType

ValueType overrides the virtual methods from Object with more appropriate implementations for value types. 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. Both 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.

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. The following example illustrates how ValueType prevents reference types from being passed to methods. 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. In each case, the method parameters are of type ValueType, and reference types are prevented from being passed to the methods.

using System;

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("value1 is not a number.");

      // Use Int64 or UInt64 as common integral type 
      if (IsInteger(value1) && IsInteger(value2)) {
         bool useUnsigned = false;
         if ((value1 is ulong && ((ulong)value1 > Int64.MaxValue)) || 
             (value2 is ulong && ((ulong) value2 > Int64.MaxValue)))
            useUnsigned = true;

         if (useUnsigned) {
            if (Math.Sign(Convert.ToDouble(value1)) < 0) 
               return NumericRelationship.LessThan;
            if (Math.Sign(Convert.ToDouble(value2)) < 0) 
               return NumericRelationship.GreaterThan;   
            return (NumericRelationship) (((ulong) value1).CompareTo((ulong) value2));            
         else {    
            long long1 = (long) value1;
            long long2 = (long) value2;
            return (NumericRelationship) long1.CompareTo(long2);
      // At least one value is floating point; use Double. 
      else {
         Double dbl1 = 0;
         Double dbl2 = 0;

         dbl1 = Convert.ToDouble(value1);
         dbl2 = Convert.ToDouble(value2);

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

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

   public static bool IsNumeric(ValueType value)
      if ( ! (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 Decimal ||
              value is Double ||
              value is Single))
            return false;
         return true;

The following example illustrates calls to the methods of the Utility class.

public class Example
   public static void Main()
      Console.WriteLine(Utility.IsNumeric(new DateTime(2012, 1, 1)));
      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

Any public static (Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Windows 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile for Smartphone, Windows Mobile for Pocket PC, Xbox 360, Zune

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

.NET Framework

Supported in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 3.5, 2.0, 1.0

XNA Framework

Supported in: 3.0, 2.0, 1.0




October 2010

Added an example.

Customer feedback.