ValueType Class

Definition

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

Inheritance

Object

ValueType

Derived

_GUID

Accessibility.__MIDL_IWinTypes_0009

Accessibility._RemotableHandle

IStream

ISymUnmanagedBinder

More…

Attributes

SerializableAttribute ComVisibleAttribute

Remarks

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.

Although ValueType is the implicit base class for value types, you cannot create a class that inherits from ValueType directly. Instead, individual compilers provide a language keyword or construct (such as struct in C# and Structure…End Structure in Visual Basic) to support the creation of value types.

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

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

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

See also

• Object
• Enum