ValueType ValueType ValueType ValueType Class

Definición

Proporciona la clase base para tipos de valores.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
Herencia
ValueTypeValueTypeValueTypeValueType
Derivado
Atributos

Comentarios

ValueType invalida los métodos virtuales de Object con implementaciones más apropiadas para los tipos de valor.ValueType overrides the virtual methods from Object with more appropriate implementations for value types. Vea también Enum, que hereda de ValueType.See also Enum, which inherits from ValueType.

Tipos de datos se dividen en tipos de valor y tipos de referencia.Data types are separated into value types and reference types. Tipos de valor se asignan a la pila o asigna insertada en una estructura.Value types are either stack-allocated or allocated inline in a structure. Tipos de referencia son asignados por montón.Reference types are heap-allocated. Tipos de referencia y valor se derivan de la clase base fundamental Object.Both reference and value types are derived from the ultimate base class Object. En casos donde es necesario para un tipo de valor que se comporten como un objeto, un contenedor que hace que el tipo de valor parezca un objeto de referencia se asigna en el montón y el valor del tipo de valor se copia en él.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. El contenedor se marca para que el sistema sepa que contiene un tipo de valor.The wrapper is marked so the system knows that it contains a value type. Este proceso se conoce como conversión boxing, y el proceso inverso se conoce como conversión unboxing.This process is known as boxing, and the reverse process is known as unboxing. Conversiones boxing y unboxing permite que cualquier tipo se trata como un objeto.Boxing and unboxing allow any type to be treated as an object.

Aunque ValueType es la clase base implícita para tipos de valor, no se puede crear una clase que hereda de ValueType directamente.Although ValueType is the implicit base class for value types, you cannot create a class that inherits from ValueType directly. En su lugar, los compiladores individuales proporcionan una palabra clave del lenguaje o construir (por ejemplo, struct en C# y Structure...End StructureInstead, individual compilers provide a language keyword or construct (such as struct in C# and StructureEnd Structure en Visual Basic) para admitir la creación de tipos de valor.in Visual Basic) to support the creation of value types.

Aparte de servir como clase base para tipos de valor en .NET Framework, el ValueType estructura no suelen usar directamente en el código.Aside from serving as the base class for value types in the .NET Framework, the ValueType structure is generally not used directly in code. Sin embargo, puede usarlo como un parámetro de llamadas de método para restringir los posibles argumentos a los tipos de valor en lugar de todos los objetos o para permitir que un método para controlar un número de tipos de valor diferente.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. El ejemplo siguiente se muestra cómo ValueType impide que los tipos de referencia que se pasan a métodos.The following example illustrates how ValueType prevents reference types from being passed to methods. Define una clase denominada Utility que contiene cuatro métodos: IsNumeric, que indica si su argumento es un número; IsInteger, que indica si su argumento es un entero; IsFloat, que indica si su argumento es un número de punto flotante; y Compare, lo que indica la relación entre dos valores numéricos.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. En cada caso, los parámetros del método son del tipo ValueType, y se impide que se pasan a los métodos de tipos de referencia.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

El ejemplo siguiente muestra las llamadas a los métodos de la Utility clase.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

Constructores

ValueType() ValueType() ValueType() ValueType()

Inicializa una nueva instancia de la clase ValueType.Initializes a new instance of the ValueType class.

Métodos

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Indica si esta instancia y un objeto especificado son iguales.Indicates whether this instance and a specified object are equal.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Devuelve el código hash de esta instancia.Returns the hash code for this instance.

GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Devuelve el nombre de tipo completo de esta instancia.Returns the fully qualified type name of this instance.

Se aplica a

Consulte también: