ValueType Třída

Definice

Poskytuje základní třídu pro typy hodnot.

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
Dědičnost
ValueType
Odvozené
Atributy

Poznámky

ValueType přepíše virtuální metody z Object pomocí vhodnějších implementací pro typy hodnot. Viz také Enum , který dědí z ValueType .

Datové typy jsou rozdělené na hodnotové typy a odkazové typy. Hodnotové typy jsou buď přidělené zásobníkem, nebo vložené ve struktuře. Odkazové typy jsou přidělené haldě. Odkazové i hodnotové typy jsou odvozeny z konečné základní třídy Object . V případech, kdy je nezbytné, aby se typ hodnoty choval jako objekt, je obálka, díky které bude tento typ hodnoty vypadat, jako by byl v haldě přidělen referenční objekt, a hodnota typu hodnoty se do ní zkopíruje. Obálka je označena, aby systém věděl, že obsahuje typ hodnoty. Tento proces se označuje jako boxing a reverzní proces se označuje jako rozbalení. Balení a rozbalení umožňuje, aby se s libovolným typem zacházel jako s objektem.

I když je implicitní základní třída pro typy hodnot, nelze vytvořit ValueType třídu, která dědí z ValueType přímo. Místo toho jednotlivé kompilátory poskytují klíčové slovo jazyka nebo konstruktor (například v struct jazyce C# a Structure ...End Structure v Visual Basic) pro podporu vytváření typů hodnot.

Kromě toho, že slouží jako základní třída pro typy hodnot v .NET Framework, se struktura obecně nepoužít ValueType přímo v kódu. Lze ji však použít jako parametr ve volání metody k omezení možných argumentů na typy hodnot místo na všechny objekty nebo k povolení metody pro zpracování několika různých typů hodnot. Následující příklad ukazuje, jak ValueType brání tomu, aby byly odkazové typy předány metodám. Definuje třídu s názvem , která obsahuje čtyři metody: , která určuje, zda je Utility IsNumeric jejím argumentem číslo; , která určuje, zda je jejím argumentem celé číslo; , která určuje, zda je jeho argumentem číslo s plovoucí desetinnou čárkou; a , která označuje vztah mezi dvěma číselnými IsInteger IsFloat Compare hodnotami. V každém případě jsou parametry metody typu a odkazové typy nejsou předány ValueType metodám.

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

Následující příklad znázorňuje volání metod třídy 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
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

Konstruktory

ValueType()

Inicializuje novou instanci ValueType třídy .

Metody

Equals(Object)

Udává, zda je tato instance totožná se zadaným objektem.

GetHashCode()

Vrátí hodnotu hash pro tuto instanci.

GetType()

Získá Type aktuální instanci.

(Zděděno od Object)
MemberwiseClone()

Vytvoří kopii aktuálního seznamu Object .

(Zděděno od Object)
ToString()

Vrátí plně kvalifikovaný název typu této instance.

Platí pro

Viz také