ValueType Classe

Définition

Fournit la classe de base pour les types valeur.

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
Héritage
ValueType
Dérivé
Attributs

Remarques

ValueType Substitue les méthodes virtuelles de Object avec des implémentations plus appropriées pour les types valeur. Voir aussi Enum , qui hérite de ValueType .

Les types de données sont séparés en types valeur et types référence. Les types valeur sont alloués par pile ou alloués inline dans une structure. Les types référence sont alloués par tas. Les types référence et valeur sont dérivés de la classe de base Ultimate Object . Dans les cas où il est nécessaire qu’un type valeur se comporte comme un objet, un wrapper qui rend le type valeur ressemble à un objet de référence qui est alloué sur le tas, et la valeur du type valeur est copiée dans celui-ci. Le wrapper est marqué pour que le système sache qu’il contient un type valeur. Ce processus est appelé boxing et le processus inverse est appelé unboxing. Le boxing et la conversion unboxing permettent de traiter tout type comme un objet.

Bien que ValueType soit la classe de base implicite pour les types valeur, vous ne pouvez pas créer une classe qui hérite ValueType directement de. Au lieu de cela, les compilateurs individuels fournissent un mot clé ou une construction de langage (par exemple, struct en C# et Structure ...End Structure dans Visual Basic) pour prendre en charge la création de types valeur.

hormis le fait qu’il s’agit de la classe de base pour les types valeur dans le .NET Framework, la ValueType structure n’est généralement pas utilisée directement dans le code. Toutefois, il peut être utilisé en tant que paramètre dans les appels de méthode pour limiter les arguments possibles aux types valeur au lieu de tous les objets, ou pour permettre à une méthode de gérer plusieurs types de valeur différents. L’exemple suivant illustre comment ValueType empêche le passage de types référence à des méthodes. Il définit une classe nommée Utility qui contient quatre méthodes : IsNumeric , qui indique si son argument est un nombre ; IsInteger , qui indique si son argument est un entier ; IsFloat , qui indique si son argument est un nombre à virgule flottante ; et Compare , qui indique la relation entre deux valeurs numériques. Dans chaque cas, les paramètres de méthode sont de type ValueType , et les types référence ne peuvent pas être passés aux méthodes.

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

L’exemple suivant illustre des appels aux méthodes de la Utility classe.

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

Constructeurs

ValueType()

Initialise une nouvelle instance de la classe ValueType.

Méthodes

Equals(Object)

Indique si cette instance et un objet spécifié sont égaux.

GetHashCode()

Retourne le code de hachage de cette instance.

GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ToString()

Retourne le nom de type qualifié complet de cette instance.

S’applique à

Voir aussi