UIntPtr Estructura

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Source:

UIntPtr.cs

Importante

Esta API no es conforme a CLS.

Representa un entero sin signo donde el ancho de bits es el mismo que un puntero.

public value class UIntPtr : IComparable<UIntPtr>, IEquatable<UIntPtr>, IParsable<UIntPtr>, ISpanParsable<UIntPtr>, IUtf8SpanParsable<UIntPtr>, System::Numerics::IAdditionOperators<UIntPtr, UIntPtr, UIntPtr>, System::Numerics::IAdditiveIdentity<UIntPtr, UIntPtr>, System::Numerics::IBinaryInteger<UIntPtr>, System::Numerics::IBinaryNumber<UIntPtr>, System::Numerics::IBitwiseOperators<UIntPtr, UIntPtr, UIntPtr>, System::Numerics::IComparisonOperators<UIntPtr, UIntPtr, bool>, System::Numerics::IDecrementOperators<UIntPtr>, System::Numerics::IDivisionOperators<UIntPtr, UIntPtr, UIntPtr>, System::Numerics::IEqualityOperators<UIntPtr, UIntPtr, bool>, System::Numerics::IIncrementOperators<UIntPtr>, System::Numerics::IMinMaxValue<UIntPtr>, System::Numerics::IModulusOperators<UIntPtr, UIntPtr, UIntPtr>, System::Numerics::IMultiplicativeIdentity<UIntPtr, UIntPtr>, System::Numerics::IMultiplyOperators<UIntPtr, UIntPtr, UIntPtr>, System::Numerics::INumber<UIntPtr>, System::Numerics::INumberBase<UIntPtr>, System::Numerics::IShiftOperators<UIntPtr, int, UIntPtr>, System::Numerics::ISubtractionOperators<UIntPtr, UIntPtr, UIntPtr>, System::Numerics::IUnaryNegationOperators<UIntPtr, UIntPtr>, System::Numerics::IUnaryPlusOperators<UIntPtr, UIntPtr>, System::Numerics::IUnsignedNumber<UIntPtr>, System::Runtime::Serialization::ISerializable

[System.CLSCompliant(false)]
public readonly struct UIntPtr : IComparable<UIntPtr>, IEquatable<UIntPtr>, IParsable<UIntPtr>, ISpanParsable<UIntPtr>, IUtf8SpanParsable<UIntPtr>, System.Numerics.IAdditionOperators<UIntPtr,UIntPtr,UIntPtr>, System.Numerics.IAdditiveIdentity<UIntPtr,UIntPtr>, System.Numerics.IBinaryInteger<UIntPtr>, System.Numerics.IBinaryNumber<UIntPtr>, System.Numerics.IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>, System.Numerics.IComparisonOperators<UIntPtr,UIntPtr,bool>, System.Numerics.IDecrementOperators<UIntPtr>, System.Numerics.IDivisionOperators<UIntPtr,UIntPtr,UIntPtr>, System.Numerics.IEqualityOperators<UIntPtr,UIntPtr,bool>, System.Numerics.IIncrementOperators<UIntPtr>, System.Numerics.IMinMaxValue<UIntPtr>, System.Numerics.IModulusOperators<UIntPtr,UIntPtr,UIntPtr>, System.Numerics.IMultiplicativeIdentity<UIntPtr,UIntPtr>, System.Numerics.IMultiplyOperators<UIntPtr,UIntPtr,UIntPtr>, System.Numerics.INumber<UIntPtr>, System.Numerics.INumberBase<UIntPtr>, System.Numerics.IShiftOperators<UIntPtr,int,UIntPtr>, System.Numerics.ISubtractionOperators<UIntPtr,UIntPtr,UIntPtr>, System.Numerics.IUnaryNegationOperators<UIntPtr,UIntPtr>, System.Numerics.IUnaryPlusOperators<UIntPtr,UIntPtr>, System.Numerics.IUnsignedNumber<UIntPtr>, System.Runtime.Serialization.ISerializable

[<System.CLSCompliant(false)>]
type unativeint = struct
    interface IFormattable
    interface IParsable<unativeint>
    interface ISpanFormattable
    interface ISpanParsable<unativeint>
    interface IAdditionOperators<unativeint, unativeint, unativeint>
    interface IAdditiveIdentity<unativeint, unativeint>
    interface IBinaryInteger<unativeint>
    interface IBinaryNumber<unativeint>
    interface IBitwiseOperators<unativeint, unativeint, unativeint>
    interface IComparisonOperators<unativeint, unativeint, bool>
    interface IEqualityOperators<unativeint, unativeint, bool>
    interface IDecrementOperators<unativeint>
    interface IDivisionOperators<unativeint, unativeint, unativeint>
    interface IIncrementOperators<unativeint>
    interface IModulusOperators<unativeint, unativeint, unativeint>
    interface IMultiplicativeIdentity<unativeint, unativeint>
    interface IMultiplyOperators<unativeint, unativeint, unativeint>
    interface INumber<unativeint>
    interface INumberBase<unativeint>
    interface ISubtractionOperators<unativeint, unativeint, unativeint>
    interface IUnaryNegationOperators<unativeint, unativeint>
    interface IUnaryPlusOperators<unativeint, unativeint>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<unativeint>
    interface IShiftOperators<unativeint, int, unativeint>
    interface IMinMaxValue<unativeint>
    interface IUnsignedNumber<unativeint>
    interface ISerializable

Public Structure UIntPtr
Implements IAdditionOperators(Of UIntPtr, UIntPtr, UIntPtr), IAdditiveIdentity(Of UIntPtr, UIntPtr), IBinaryInteger(Of UIntPtr), IBinaryNumber(Of UIntPtr), IBitwiseOperators(Of UIntPtr, UIntPtr, UIntPtr), IComparable(Of UIntPtr), IComparisonOperators(Of UIntPtr, UIntPtr, Boolean), IDecrementOperators(Of UIntPtr), IDivisionOperators(Of UIntPtr, UIntPtr, UIntPtr), IEqualityOperators(Of UIntPtr, UIntPtr, Boolean), IEquatable(Of UIntPtr), IIncrementOperators(Of UIntPtr), IMinMaxValue(Of UIntPtr), IModulusOperators(Of UIntPtr, UIntPtr, UIntPtr), IMultiplicativeIdentity(Of UIntPtr, UIntPtr), IMultiplyOperators(Of UIntPtr, UIntPtr, UIntPtr), INumber(Of UIntPtr), INumberBase(Of UIntPtr), IParsable(Of UIntPtr), ISerializable, IShiftOperators(Of UIntPtr, Integer, UIntPtr), ISpanParsable(Of UIntPtr), ISubtractionOperators(Of UIntPtr, UIntPtr, UIntPtr), IUnaryNegationOperators(Of UIntPtr, UIntPtr), IUnaryPlusOperators(Of UIntPtr, UIntPtr), IUnsignedNumber(Of UIntPtr), IUtf8SpanParsable(Of UIntPtr)

Herencia

Object

ValueType

UIntPtr

Atributos

CLSCompliantAttribute

Implementaciones

IComparable IComparable<UIntPtr> IEquatable<UIntPtr> IFormattable ISerializable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<UIntPtr> IParsable<TSelf> ISpanParsable<UIntPtr> ISpanParsable<TSelf> IAdditionOperators<UIntPtr,UIntPtr,UIntPtr> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<UIntPtr,UIntPtr> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<UIntPtr> IBinaryNumber<UIntPtr> IBinaryNumber<TSelf> IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<UIntPtr,UIntPtr,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<UIntPtr> IDecrementOperators<TSelf> IDivisionOperators<UIntPtr,UIntPtr,UIntPtr> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<UIntPtr,UIntPtr,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IIncrementOperators<UIntPtr> IIncrementOperators<TSelf> IMinMaxValue<UIntPtr> IModulusOperators<UIntPtr,UIntPtr,UIntPtr> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<UIntPtr,UIntPtr> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<UIntPtr,UIntPtr,UIntPtr> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<UIntPtr> INumber<TSelf> INumberBase<UIntPtr> INumberBase<TSelf> IShiftOperators<UIntPtr,Int32,UIntPtr> IShiftOperators<TSelf,Int32,TSelf> ISubtractionOperators<UIntPtr,UIntPtr,UIntPtr> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<UIntPtr,UIntPtr> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<UIntPtr,UIntPtr> IUnaryPlusOperators<TSelf,TSelf> IUnsignedNumber<UIntPtr> IUtf8SpanFormattable IUtf8SpanParsable<UIntPtr> IUtf8SpanParsable<TSelf>

Comentarios

El tipo UIntPtr está diseñado para ser un entero cuyo tamaño es el mismo que un puntero. Es decir, se espera que una instancia de este tipo sea de 32 bits en un proceso de 32 bits y 64 bits en un proceso de 64 bits.

Los idiomas que admiten punteros pueden usar el tipo UIntPtr y como medio común de hacer referencia a datos entre idiomas que sí y no admiten punteros. UIntPtr objetos también se pueden usar para contener identificadores.

Nota

El uso de UIntPtr como puntero o un identificador es propenso a errores y no es seguro. Es simplemente un tipo entero que se puede usar como formato de intercambio para punteros y identificadores debido a que tiene el mismo tamaño. Fuera de requisitos de intercambio específicos, como para pasar datos a un lenguaje que no admite punteros, se debe usar un puntero con tipo correcto para representar punteros y SafeHandle para representar identificadores.

Este tipo implementa el ISerializable. En .NET 5 y versiones posteriores, este tipo también implementa las interfaces IFormattable. En .NET 7 y versiones posteriores, este tipo también implementa las interfaces de IBinaryInteger<TSelf>, IMinMaxValue<TSelf>y IUnsignedNumber<TSelf>.

En C# a partir de la versión 9.0, puede usar el tipo de nuint integrado para definir enteros de tamaño nativo. Este tipo se representa mediante el tipo UIntPtr internamente y proporciona operaciones y conversiones que son adecuadas para los tipos enteros. Para obtener más información, vea tipos nint y nuint.

En C# a partir de la versión 11 y al tener como destino .NET 7 o posterior runtime, nuint es un alias para UIntPtr de la misma manera que uint es un alias para UInt32.

Constructores

UIntPtr(UInt32)	Inicializa una nueva instancia de la estructura UIntPtr utilizando el entero de 32 bits sin signo especificado.
UIntPtr(UInt64)	Inicializa una nueva instancia de UIntPtr con el entero de 64 bits sin signo especificado.
UIntPtr(Void*)	Inicializa una nueva instancia de UIntPtr usando el puntero especificado a un tipo no especificado.

Campos

Zero	Campo de solo lectura que representa un entero sin signo que se ha inicializado en cero.

Propiedades

MaxValue	Representa el valor más grande posible de UIntPtr.
MinValue	Representa el valor más pequeño posible de UIntPtr.
Size	Obtiene el tamaño de esta instancia.

Métodos

Add(UIntPtr, Int32)	Agrega un desplazamiento a un entero sin signo.
Clamp(UIntPtr, UIntPtr, UIntPtr)	Fija un valor en un valor mínimo inclusivo y máximo.
CompareTo(Object)	Compara la instancia actual con otro objeto del mismo tipo y devuelve un entero que indica si la instancia actual precede, sigue o se produce en la misma posición en el criterio de ordenación que el otro objeto.
CompareTo(UIntPtr)	Compara la instancia actual con otro objeto del mismo tipo y devuelve un entero que indica si la instancia actual precede, sigue o se produce en la misma posición en el criterio de ordenación que el otro objeto.
CreateChecked<TOther>(TOther)	Crea una instancia del tipo actual a partir de un valor, iniciando una excepción de desbordamiento para los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
CreateSaturating<TOther>(TOther)	Crea una instancia del tipo actual a partir de un valor, saturando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
CreateTruncating<TOther>(TOther)	Crea una instancia del tipo actual a partir de un valor, truncando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
DivRem(UIntPtr, UIntPtr)	Calcula el cociente y el resto de dos valores.
Equals(Object)	Devuelve un valor que indica si esta instancia es igual a un objeto especificado.
Equals(UIntPtr)	Indica si el objeto actual es igual a otro objeto del mismo tipo.
GetHashCode()	Devuelve el código hash de esta instancia.
IsEvenInteger(UIntPtr)	Determina si un valor representa un número entero par.
IsOddInteger(UIntPtr)	Determina si un valor representa un número entero impar.
IsPow2(UIntPtr)	Determina si un valor es una potencia de dos.
LeadingZeroCount(UIntPtr)	Calcula el número de ceros iniciales en un valor.
Log2(UIntPtr)	Calcula el registro2 de un valor.
Max(UIntPtr, UIntPtr)	Compara dos valores con el proceso, que es mayor.
Min(UIntPtr, UIntPtr)	Compara dos valores con el proceso, que es menor.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analiza un intervalo de caracteres UTF-8 en un valor.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analiza un intervalo de caracteres UTF-8 en un valor.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analiza un intervalo de caracteres en un valor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convierte el intervalo de caracteres de solo lectura de una representación de caracteres de un número en estilo especificado opcionalmente y, opcionalmente, el formato específico de la referencia cultural especificado en su entero nativo sin signo equivalente.
Parse(String)	Convierte la representación de cadena de un número en su entero nativo sin signo equivalente.
Parse(String, IFormatProvider)	Convierte la representación de cadena de un número en un formato específico de la referencia cultural especificado en su entero nativo sin signo equivalente.
Parse(String, NumberStyles)	Convierte la representación de cadena de un número en un estilo especificado en su entero nativo sin signo equivalente.
Parse(String, NumberStyles, IFormatProvider)	Convierte la representación de cadena de un número en un estilo y formato específico de la referencia cultural especificados en su entero nativo sin signo equivalente.
PopCount(UIntPtr)	Calcula el número de bits que se establecen en un valor.
RotateLeft(UIntPtr, Int32)	Gira un valor de izquierda por una cantidad determinada.
RotateRight(UIntPtr, Int32)	Gira un valor a la derecha por una cantidad determinada.
Sign(UIntPtr)	Calcula el signo de un valor.
Subtract(UIntPtr, Int32)	Resta un desplazamiento de un entero sin signo.
ToPointer()	Convierte el valor de esta instancia en un puntero a un tipo no especificado.
ToString()	Convierte el valor numérico de esta instancia en su representación de cadena equivalente.
ToString(IFormatProvider)	Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante el formato especificado y la información de formato específica de la referencia cultural.
ToString(String)	Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante el formato especificado.
ToString(String, IFormatProvider)	Da formato al valor de la instancia actual mediante el formato especificado.
ToUInt32()	Convierte el valor de esta instancia en un entero de 32 bits sin signo.
ToUInt64()	Convierte el valor de esta instancia en un entero de 64 bits sin signo.
TrailingZeroCount(UIntPtr)	Calcula el número de ceros finales en un valor.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia actual como UTF-8 en el intervalo de bytes proporcionado.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia actual en el intervalo de caracteres proporcionado.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, UIntPtr)	Intenta analizar un intervalo de caracteres UTF-8 en un valor.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, UIntPtr)	Intenta analizar un intervalo de caracteres UTF-8 en un valor.
TryParse(ReadOnlySpan<Byte>, UIntPtr)	Intenta convertir un intervalo de caracteres UTF-8 que contiene la representación de cadena de un número en su entero sin signo equivalente.
TryParse(ReadOnlySpan<Char>, IFormatProvider, UIntPtr)	Intenta analizar una cadena en un valor.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, UIntPtr)	Convierte el intervalo de caracteres de solo lectura de un número en un estilo especificado y un formato específico de la referencia cultural en su entero nativo sin signo equivalente. Un valor devuelto indica si la conversión se realizó correctamente.
TryParse(ReadOnlySpan<Char>, UIntPtr)	Convierte el intervalo de caracteres de solo lectura de una representación de caracteres de un número en su entero nativo sin signo equivalente. Un valor devuelto indica si la conversión se realizó correctamente.
TryParse(String, IFormatProvider, UIntPtr)	Intenta analizar una cadena en un valor.
TryParse(String, NumberStyles, IFormatProvider, UIntPtr)	Convierte la representación de cadena de un número en un estilo y formato específico de la referencia cultural especificados en su entero nativo sin signo equivalente. Un valor devuelto indica si la conversión se realizó correctamente.
TryParse(String, UIntPtr)	Convierte la representación de cadena de un número en su entero nativo sin signo equivalente. Un valor devuelto indica si la conversión se realizó correctamente.

Operadores

Addition(UIntPtr, Int32)	Agrega un desplazamiento a un entero sin signo.
Equality(UIntPtr, UIntPtr)	Determina si dos instancias especificadas de UIntPtr son iguales.
Explicit(UInt32 to UIntPtr)	Convierte el valor de un entero de 32 bits sin signo en un UIntPtr.
Explicit(UInt64 to UIntPtr)	Convierte el valor de un entero de 64 bits sin signo en un UIntPtr.
Explicit(UIntPtr to UInt32)	Convierte el valor del UIntPtr especificado en un entero de 32 bits sin signo.
Explicit(UIntPtr to UInt64)	Convierte el valor del UIntPtr especificado en un entero de 64 bits sin signo.
Explicit(UIntPtr to Void*)	Convierte el valor del UIntPtr especificado en un puntero a un tipo no especificado. Esta API no es compatible con CLS.
Explicit(Void* to UIntPtr)	Convierte el puntero especificado en un tipo no especificado en un UIntPtr. Esta API no es compatible con CLS.
Inequality(UIntPtr, UIntPtr)	Determina si dos instancias especificadas de UIntPtr no son iguales.
Subtraction(UIntPtr, Int32)	Resta un desplazamiento de un entero sin signo.

Implementaciones de interfaz explícitas

IAdditionOperators<UIntPtr,UIntPtr,UIntPtr>.Addition(UIntPtr, UIntPtr)	Agrega dos valores juntos para calcular su suma.
IAdditionOperators<UIntPtr,UIntPtr,UIntPtr>.CheckedAddition(UIntPtr, UIntPtr)	Agrega dos valores juntos para calcular su suma.
IAdditiveIdentity<UIntPtr,UIntPtr>.AdditiveIdentity	Obtiene la identidad de suma del tipo actual.
IBinaryInteger<UIntPtr>.GetByteCount()	Obtiene el número de bytes que se escribirán como parte de TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<UIntPtr>.GetShortestBitLength()	Obtiene la longitud, en bits, de la representación complementaria de dos más corta del valor actual.
IBinaryInteger<UIntPtr>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, UIntPtr)	Representa un entero sin signo donde el ancho de bits es el mismo que un puntero.
IBinaryInteger<UIntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, UIntPtr)	Representa un entero sin signo donde el ancho de bits es el mismo que un puntero.
IBinaryInteger<UIntPtr>.TryWriteBigEndian(Span<Byte>, Int32)	Intenta escribir el valor actual, en formato big-endian, en un intervalo determinado.
IBinaryInteger<UIntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)	Intenta escribir el valor actual, en formato little-endian, en un intervalo determinado.
IBinaryNumber<UIntPtr>.AllBitsSet	Obtiene una instancia del tipo binario en el que se establecen todos los bits.
IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.BitwiseAnd(UIntPtr, UIntPtr)	Calcula los valores bit a bit y de dos valores.
IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.BitwiseOr(UIntPtr, UIntPtr)	Calcula el bit a bit o de dos valores.
IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.ExclusiveOr(UIntPtr, UIntPtr)	Calcula el valor exclusivo o de dos valores.
IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.OnesComplement(UIntPtr)	Calcula la representación ones-complement de un valor determinado.
IComparisonOperators<UIntPtr,UIntPtr,Boolean>.GreaterThan(UIntPtr, UIntPtr)	Compara dos valores para determinar cuál es mayor.
IComparisonOperators<UIntPtr,UIntPtr,Boolean>.GreaterThanOrEqual(UIntPtr, UIntPtr)	Compara dos valores para determinar cuál es mayor o igual.
IComparisonOperators<UIntPtr,UIntPtr,Boolean>.LessThan(UIntPtr, UIntPtr)	Compara dos valores para determinar cuál es menor.
IComparisonOperators<UIntPtr,UIntPtr,Boolean>.LessThanOrEqual(UIntPtr, UIntPtr)	Compara dos valores para determinar cuál es menor o igual.
IDecrementOperators<UIntPtr>.CheckedDecrement(UIntPtr)	Disminuye un valor.
IDecrementOperators<UIntPtr>.Decrement(UIntPtr)	Disminuye un valor.
IDivisionOperators<UIntPtr,UIntPtr,UIntPtr>.Division(UIntPtr, UIntPtr)	Divide un valor por otro para calcular su cociente.
IIncrementOperators<UIntPtr>.CheckedIncrement(UIntPtr)	Incrementa un valor.
IIncrementOperators<UIntPtr>.Increment(UIntPtr)	Incrementa un valor.
IMinMaxValue<UIntPtr>.MaxValue	Obtiene el valor máximo del tipo actual.
IMinMaxValue<UIntPtr>.MinValue	Obtiene el valor mínimo del tipo actual.
IModulusOperators<UIntPtr,UIntPtr,UIntPtr>.Modulus(UIntPtr, UIntPtr)	Divide dos valores juntos para calcular su módulo o resto.
IMultiplicativeIdentity<UIntPtr,UIntPtr>.MultiplicativeIdentity	Obtiene la identidad multiplicativa del tipo actual.
IMultiplyOperators<UIntPtr,UIntPtr,UIntPtr>.CheckedMultiply(UIntPtr, UIntPtr)	Multiplica dos valores juntos para calcular su producto.
IMultiplyOperators<UIntPtr,UIntPtr,UIntPtr>.Multiply(UIntPtr, UIntPtr)	Multiplica dos valores juntos para calcular su producto.
INumber<UIntPtr>.CopySign(UIntPtr, UIntPtr)	Copia el signo de un valor en el signo de otro valor.
INumber<UIntPtr>.MaxNumber(UIntPtr, UIntPtr)	Compara dos valores con el proceso, que es mayor y devuelve el otro valor si una entrada es NaN.
INumber<UIntPtr>.MinNumber(UIntPtr, UIntPtr)	Compara dos valores con el proceso, que es menor y devuelve el otro valor si una entrada es NaN.
INumberBase<UIntPtr>.Abs(UIntPtr)	Calcula el valor absoluto de un valor.
INumberBase<UIntPtr>.IsCanonical(UIntPtr)	Determina si un valor está en su representación canónica.
INumberBase<UIntPtr>.IsComplexNumber(UIntPtr)	Determina si un valor representa un número complejo.
INumberBase<UIntPtr>.IsFinite(UIntPtr)	Determina si un valor es finito.
INumberBase<UIntPtr>.IsImaginaryNumber(UIntPtr)	Determina si un valor representa un número imaginario puro.
INumberBase<UIntPtr>.IsInfinity(UIntPtr)	Determina si un valor es infinito.
INumberBase<UIntPtr>.IsInteger(UIntPtr)	Determina si un valor representa un número entero.
INumberBase<UIntPtr>.IsNaN(UIntPtr)	Determina si un valor es NaN.
INumberBase<UIntPtr>.IsNegative(UIntPtr)	Determina si un valor es negativo.
INumberBase<UIntPtr>.IsNegativeInfinity(UIntPtr)	Determina si un valor es infinito negativo.
INumberBase<UIntPtr>.IsNormal(UIntPtr)	Determina si un valor es normal.
INumberBase<UIntPtr>.IsPositive(UIntPtr)	Determina si un valor es positivo.
INumberBase<UIntPtr>.IsPositiveInfinity(UIntPtr)	Determina si un valor es infinito positivo.
INumberBase<UIntPtr>.IsRealNumber(UIntPtr)	Determina si un valor representa un número real.
INumberBase<UIntPtr>.IsSubnormal(UIntPtr)	Determina si un valor es subnormal.
INumberBase<UIntPtr>.IsZero(UIntPtr)	Determina si un valor es cero.
INumberBase<UIntPtr>.MaxMagnitude(UIntPtr, UIntPtr)	Compara dos valores con el proceso, que es mayor.
INumberBase<UIntPtr>.MaxMagnitudeNumber(UIntPtr, UIntPtr)	Compara dos valores con el proceso que tiene la magnitud mayor y devuelve el otro valor si una entrada es NaN.
INumberBase<UIntPtr>.MinMagnitude(UIntPtr, UIntPtr)	Compara dos valores con el proceso, que es menor.
INumberBase<UIntPtr>.MinMagnitudeNumber(UIntPtr, UIntPtr)	Compara dos valores con el proceso que tiene la magnitud menor y devuelve el otro valor si una entrada es NaN.
INumberBase<UIntPtr>.One	Obtiene el valor 1 para el tipo.
INumberBase<UIntPtr>.Radix	Obtiene el radix, o base, para el tipo .
INumberBase<UIntPtr>.TryConvertFromChecked<TOther>(TOther, UIntPtr)	Representa un entero sin signo donde el ancho de bits es el mismo que un puntero.
INumberBase<UIntPtr>.TryConvertFromSaturating<TOther>(TOther, UIntPtr)	Representa un entero sin signo donde el ancho de bits es el mismo que un puntero.
INumberBase<UIntPtr>.TryConvertFromTruncating<TOther>(TOther, UIntPtr)	Representa un entero sin signo donde el ancho de bits es el mismo que un puntero.
INumberBase<UIntPtr>.TryConvertToChecked<TOther>(UIntPtr, TOther)	Intenta convertir una instancia del tipo actual en otro tipo, iniciando una excepción de desbordamiento para los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
INumberBase<UIntPtr>.TryConvertToSaturating<TOther>(UIntPtr, TOther)	Intenta convertir una instancia del tipo actual en otro tipo, saturando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
INumberBase<UIntPtr>.TryConvertToTruncating<TOther>(UIntPtr, TOther)	Intenta convertir una instancia del tipo actual en otro tipo, truncando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
INumberBase<UIntPtr>.Zero	Obtiene el valor 0 para el tipo.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Rellena un objeto SerializationInfo con los datos necesarios para serializar el objeto UIntPtr actual.
IShiftOperators<UIntPtr,Int32,UIntPtr>.LeftShift(UIntPtr, Int32)	Desplaza un valor dejado por una cantidad determinada.
IShiftOperators<UIntPtr,Int32,UIntPtr>.RightShift(UIntPtr, Int32)	Desplaza un valor hacia la derecha por una cantidad determinada.
IShiftOperators<UIntPtr,Int32,UIntPtr>.UnsignedRightShift(UIntPtr, Int32)	Desplaza un valor hacia la derecha por una cantidad determinada.
ISubtractionOperators<UIntPtr,UIntPtr,UIntPtr>.CheckedSubtraction(UIntPtr, UIntPtr)	Resta dos valores para calcular su diferencia.
ISubtractionOperators<UIntPtr,UIntPtr,UIntPtr>.Subtraction(UIntPtr, UIntPtr)	Resta dos valores para calcular su diferencia.
IUnaryNegationOperators<UIntPtr,UIntPtr>.CheckedUnaryNegation(UIntPtr)	Calcula la negación unaria activada de un valor.
IUnaryNegationOperators<UIntPtr,UIntPtr>.UnaryNegation(UIntPtr)	Calcula la negación unaria de un valor.
IUnaryPlusOperators<UIntPtr,UIntPtr>.UnaryPlus(UIntPtr)	Calcula la unaria más de un valor.

Seguridad para subprocesos

Este tipo es seguro para subprocesos.

Consulte también

• IntPtr