UIntPtr Estructura

Definición

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
public value class UIntPtr : IComparable, IComparable<UIntPtr>, IEquatable<UIntPtr>, IFormattable, System::Runtime::Serialization::ISerializable
public value class UIntPtr : IComparable, IComparable<UIntPtr>, IEquatable<UIntPtr>, ISpanFormattable, System::Runtime::Serialization::ISerializable
public value class UIntPtr : IComparable<UIntPtr>, IEquatable<UIntPtr>, IParsable<UIntPtr>, ISpanParsable<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>, System::Numerics::IDecrementOperators<UIntPtr>, System::Numerics::IDivisionOperators<UIntPtr, UIntPtr, UIntPtr>, System::Numerics::IEqualityOperators<UIntPtr, UIntPtr>, 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, 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
public value class UIntPtr : IEquatable<UIntPtr>, System::Runtime::Serialization::ISerializable
public value class UIntPtr : System::Runtime::Serialization::ISerializable
[System.CLSCompliant(false)]
public struct UIntPtr
[System.CLSCompliant(false)]
public readonly struct UIntPtr : IComparable, IComparable<UIntPtr>, IEquatable<UIntPtr>, IFormattable, System.Runtime.Serialization.ISerializable
[System.CLSCompliant(false)]
public readonly struct UIntPtr : IComparable, IComparable<UIntPtr>, IEquatable<UIntPtr>, ISpanFormattable, System.Runtime.Serialization.ISerializable
[System.CLSCompliant(false)]
public readonly struct UIntPtr : IComparable<UIntPtr>, IEquatable<UIntPtr>, IParsable<UIntPtr>, ISpanParsable<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>, System.Numerics.IDecrementOperators<UIntPtr>, System.Numerics.IDivisionOperators<UIntPtr,UIntPtr,UIntPtr>, System.Numerics.IEqualityOperators<UIntPtr,UIntPtr>, 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,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 struct UIntPtr : IEquatable<UIntPtr>, System.Runtime.Serialization.ISerializable
[System.CLSCompliant(false)]
public readonly struct UIntPtr : IEquatable<UIntPtr>, System.Runtime.Serialization.ISerializable
[System.CLSCompliant(false)]
[System.Serializable]
public struct UIntPtr : System.Runtime.Serialization.ISerializable
[System.CLSCompliant(false)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct UIntPtr : System.Runtime.Serialization.ISerializable
[System.CLSCompliant(false)]
public struct UIntPtr : System.Runtime.Serialization.ISerializable
[<System.CLSCompliant(false)>]
type unativeint = struct
[<System.CLSCompliant(false)>]
type unativeint = struct
    interface IFormattable
    interface ISerializable
[<System.CLSCompliant(false)>]
type unativeint = struct
    interface ISpanFormattable
    interface IFormattable
    interface 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>
    interface IEqualityOperators<unativeint, unativeint>
    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 IShiftOperators<unativeint, unativeint>
    interface IMinMaxValue<unativeint>
    interface IUnsignedNumber<unativeint>
    interface ISerializable
[<System.CLSCompliant(false)>]
type unativeint = struct
    interface ISerializable
[<System.CLSCompliant(false)>]
[<System.Serializable>]
type unativeint = struct
    interface ISerializable
[<System.CLSCompliant(false)>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type unativeint = struct
    interface ISerializable
Public Structure UIntPtr
Public Structure UIntPtr
Implements IComparable, IComparable(Of UIntPtr), IEquatable(Of UIntPtr), IFormattable, ISerializable
Public Structure UIntPtr
Implements IComparable, IComparable(Of UIntPtr), IEquatable(Of UIntPtr), ISerializable, ISpanFormattable
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), IDecrementOperators(Of UIntPtr), IDivisionOperators(Of UIntPtr, UIntPtr, UIntPtr), IEqualityOperators(Of UIntPtr, UIntPtr), 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, UIntPtr), ISpanParsable(Of UIntPtr), ISubtractionOperators(Of UIntPtr, UIntPtr, UIntPtr), IUnaryNegationOperators(Of UIntPtr, UIntPtr), IUnaryPlusOperators(Of UIntPtr, UIntPtr), IUnsignedNumber(Of UIntPtr)
Public Structure UIntPtr
Implements IEquatable(Of UIntPtr), ISerializable
Public Structure UIntPtr
Implements ISerializable
Herencia
UIntPtr
Atributos
Implementaciones
IComparable IComparable<UIntPtr> IEquatable<UIntPtr> IFormattable ISerializable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> 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> System.Numerics.IComparisonOperators<UIntPtr,UIntPtr> System.Numerics.IComparisonOperators<TSelf,TSelf> IDecrementOperators<UIntPtr> IDecrementOperators<TSelf> IDivisionOperators<UIntPtr,UIntPtr,UIntPtr> IDivisionOperators<TSelf,TSelf,TSelf> System.Numerics.IEqualityOperators<UIntPtr,UIntPtr> System.Numerics.IEqualityOperators<TSelf,TOther> System.Numerics.IEqualityOperators<TSelf,TSelf> 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> System.Numerics.IShiftOperators<UIntPtr,UIntPtr> System.Numerics.IShiftOperators<TSelf,TSelf> ISubtractionOperators<UIntPtr,UIntPtr,UIntPtr> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<UIntPtr,UIntPtr> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<UIntPtr,UIntPtr> IUnaryPlusOperators<TSelf,TSelf> IUnsignedNumber<UIntPtr>

Comentarios

El UIntPtr tipo 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 UIntPtr tipo y como medio común de hacer referencia a datos entre idiomas que sí y no admiten punteros. UIntPtr Los objetos también se pueden usar para contener identificadores.

Nota

El uso UIntPtr de 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 se debe usar para representar identificadores.

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

En C# a partir de la versión 9.0, puede usar el tipo integrado nuint para definir enteros de tamaño nativo. Este tipo se representa mediante el UIntPtr tipo internamente y proporciona operaciones y conversiones 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 cuando el destino es el entorno de ejecución de .NET 7 o posterior, nuint es un alias de UIntPtr la misma manera que uint un alias para UInt32.

Constructores

UIntPtr(UInt32)

Inicializa una nueva instancia de la UIntPtr estructura utilizando el entero de 32 bits sin signo especificado.

UIntPtr(UInt64)

Inicializa una nueva instancia de UIntPtr utilizando 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 mayor valor posible de UIntPtr.

MinValue

Representa el menor valor 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)

Sujeta un valor a 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 posición de la instancia actual es anterior, posterior o igual que la del otro objeto en el criterio de ordenación.

CompareTo(UIntPtr)

Compara la instancia actual con otro objeto del mismo tipo y devuelve un entero que indica si la posición de la instancia actual es anterior, posterior o igual que la del otro objeto en el criterio de ordenación.

DivRem(UIntPtr, UIntPtr)

Calcula el cociente y el resto de dos valores.

Equals(Object)

Devuelve un valor que indica si esta instancia equivale a un objeto especificado.

Equals(UIntPtr)

Indica si el objeto actual es igual que 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<Char>, IFormatProvider)
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 en forma de cadena de un número con el formato específico de la referencia cultural que se haya especificado en el entero nativo sin signo equivalente.

Parse(String, NumberStyles)

Convierte la representación en forma de cadena de un número del estilo especificado en el entero nativo sin signo equivalente.

Parse(String, NumberStyles, IFormatProvider)

Convierte la representación en forma de cadena de un número con el estilo y el formato específicos de la referencia cultural que se hayan especificado en el entero nativo sin signo equivalente.

PopCount(UIntPtr)

Calcula el número de bits establecidos en un valor.

RotateLeft(UIntPtr, Int32)

Gira un valor a la 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 a un puntero a un tipo no especificado.

ToString()

Convierte el valor numérico de esta instancia en la 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 y la información de formato específica de la referencia cultural que se especificaran.

ToString(String)

Convierte el valor numérico de esta instancia en la representación de cadena equivalente usando el formato especificado.

ToString(String, IFormatProvider)

Da formato al valor de la instancia actual usando 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<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Intenta dar formato al valor de la instancia actual en el intervalo de caracteres proporcionado.

TryParse(ReadOnlySpan<Char>, IFormatProvider, UIntPtr)
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, UIntPtr)

Convierte el intervalo de caracteres de solo lectura de una representación de caracteres 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 en su entero nativo sin signo equivalente. Un valor devuelto indica si la conversión se realizó correctamente.

TryParse(String, IFormatProvider, UIntPtr)
TryParse(String, NumberStyles, IFormatProvider, UIntPtr)

Convierte la representación en forma de cadena de un número con el estilo y el formato específicos de la referencia cultural que se hayan especificado en el 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 conforme a CLS.

Explicit(Void* to UIntPtr)

Convierte el puntero especificado a un tipo no especificado en un UIntPtr.

Esta API no es conforme a 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

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

IEquatable<UIntPtr>.Equals(UIntPtr)

Devuelve un valor que indica si esta instancia es igual a otro entero sin signo.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Rellena un objeto SerializationInfo con los datos necesarios para serializar el objeto UIntPtr actual.

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.

Consulte también