UIntPtr Estrutura

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Origem:

UIntPtr.cs

Importante

Esta API não está em conformidade com CLS.

Representa um inteiro sem sinal em que a largura do bit é igual a um ponteiro.

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)

Herança

Object

ValueType

UIntPtr

Atributos

CLSCompliantAttribute

Implementações

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>

Comentários

O tipo UIntPtr foi projetado para ser um inteiro cujo tamanho é o mesmo que um ponteiro. Ou seja, espera-se que uma instância desse tipo seja de 32 bits em um processo de 32 bits e 64 bits em um processo de 64 bits.

O tipo de UIntPtr pode ser usado por idiomas que dão suporte a ponteiros e como um meio comum de se referir a dados entre idiomas que dão suporte a ponteiros. UIntPtr objetos também podem ser usados para armazenar identificadores.

Nota

Usar UIntPtr como ponteiro ou identificador é propenso a erros e não seguro. É simplesmente um tipo inteiro que pode ser usado como um formato de intercâmbio para ponteiros e identificadores devido ao mesmo tamanho. Fora dos requisitos de intercâmbio específicos, como passar dados para um idioma que não dá suporte a ponteiros, um ponteiro digitado corretamente deve ser usado para representar ponteiros e SafeHandle deve ser usado para representar identificadores.

Esse tipo implementa o ISerializable. No .NET 5 e versões posteriores, esse tipo também implementa as interfaces de IFormattable. No .NET 7 e versões posteriores, esse tipo também implementa as interfaces IBinaryInteger<TSelf>, IMinMaxValue<TSelf>e IUnsignedNumber<TSelf>.

No C# a partir da versão 9.0, você pode usar o tipo de nuint interno para definir inteiros de tamanho nativo. Esse tipo é representado pelo tipo UIntPtr internamente e fornece operações e conversões apropriadas para tipos inteiros. Para obter mais informações, consulte tipos nint e nuint.

No C# a partir da versão 11 e ao direcionar o runtime do .NET 7 ou posterior, nuint é um alias para UIntPtr da mesma forma que uint é um alias para UInt32.

Construtores

UIntPtr(UInt32)	Inicializa uma nova instância da estrutura UIntPtr usando o inteiro sem sinal de 32 bits especificado.
UIntPtr(UInt64)	Inicializa uma nova instância de UIntPtr usando o inteiro sem sinal de 64 bits especificado.
UIntPtr(Void*)	Inicializa uma nova instância de UIntPtr usando o ponteiro especificado para um tipo não especificado.

Campos

Zero	Um campo somente leitura que representa um inteiro sem sinal que foi inicializado como zero.

Propriedades

MaxValue	Representa o maior valor possível de UIntPtr.
MinValue	Representa o menor valor possível de UIntPtr.
Size	Obtém o tamanho dessa instância.

Métodos

Add(UIntPtr, Int32)	Adiciona um deslocamento a um inteiro sem sinal.
Clamp(UIntPtr, UIntPtr, UIntPtr)	Fixa um valor a um valor mínimo inclusivo e máximo.
CompareTo(Object)	Compara a instância atual com outro objeto do mesmo tipo e retorna um inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição na ordem de classificação que o outro objeto.
CompareTo(UIntPtr)	Compara a instância atual com outro objeto do mesmo tipo e retorna um inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição na ordem de classificação que o outro objeto.
CreateChecked<TOther>(TOther)	Cria uma instância do tipo atual de um valor, gerando uma exceção de estouro para quaisquer valores que fiquem fora do intervalo representável do tipo atual.
CreateSaturating<TOther>(TOther)	Cria uma instância do tipo atual de um valor, saturando todos os valores que estão fora do intervalo representável do tipo atual.
CreateTruncating<TOther>(TOther)	Cria uma instância do tipo atual de um valor, truncando todos os valores que estão fora do intervalo representável do tipo atual.
DivRem(UIntPtr, UIntPtr)	Calcula o quociente e o restante de dois valores.
Equals(Object)	Retorna um valor que indica se essa instância é igual a um objeto especificado.
Equals(UIntPtr)	Indica se o objeto atual é igual a outro objeto do mesmo tipo.
GetHashCode()	Retorna o código hash dessa instância.
IsEvenInteger(UIntPtr)	Determina se um valor representa um número integral par.
IsOddInteger(UIntPtr)	Determina se um valor representa um número integral ímpar.
IsPow2(UIntPtr)	Determina se um valor é uma potência de dois.
LeadingZeroCount(UIntPtr)	Calcula o número de zeros à esquerda em um valor.
Log2(UIntPtr)	Calcula o log2 de um valor.
Max(UIntPtr, UIntPtr)	Compara dois valores com a computação que é maior.
Min(UIntPtr, UIntPtr)	Compara dois valores com a computação menor.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analisa um intervalo de caracteres UTF-8 em um valor.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analisa um intervalo de caracteres UTF-8 em um valor.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analisa um intervalo de caracteres em um valor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Converte o intervalo somente leitura de representação de caracteres de um número no estilo opcionalmente especificado e, opcionalmente, o formato específico da cultura especificado em seu equivalente inteiro nativo sem sinal.
Parse(String)	Converte a representação de cadeia de caracteres de um número em seu equivalente inteiro nativo sem sinal.
Parse(String, IFormatProvider)	Converte a representação de cadeia de caracteres de um número em um formato específico à cultura especificado em seu equivalente inteiro nativo sem sinal.
Parse(String, NumberStyles)	Converte a representação de cadeia de caracteres de um número em um estilo especificado em seu equivalente inteiro nativo sem sinal.
Parse(String, NumberStyles, IFormatProvider)	Converte a representação de cadeia de caracteres de um número em um formato específico de estilo e cultura especificado em seu equivalente inteiro nativo sem sinal.
PopCount(UIntPtr)	Calcula o número de bits definidos em um valor.
RotateLeft(UIntPtr, Int32)	Gira um valor deixado por um determinado valor.
RotateRight(UIntPtr, Int32)	Gira um valor à direita em um determinado valor.
Sign(UIntPtr)	Calcula o sinal de um valor.
Subtract(UIntPtr, Int32)	Subtrai um deslocamento de um inteiro sem sinal.
ToPointer()	Converte o valor dessa instância em um ponteiro em um tipo não especificado.
ToString()	Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente.
ToString(IFormatProvider)	Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente usando o formato especificado e as informações de formato específicas da cultura.
ToString(String)	Converte o valor numérico dessa instância em sua representação de cadeia de caracteres equivalente usando o formato especificado.
ToString(String, IFormatProvider)	Formata o valor da instância atual usando o formato especificado.
ToUInt32()	Converte o valor dessa instância em um inteiro sem sinal de 32 bits.
ToUInt64()	Converte o valor dessa instância em um inteiro sem sinal de 64 bits.
TrailingZeroCount(UIntPtr)	Calcula o número de zeros à direita em um valor.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da instância atual como UTF-8 no intervalo de bytes fornecido.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da instância atual no intervalo de caracteres fornecido.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, UIntPtr)	Tenta analisar um intervalo de caracteres UTF-8 em um valor.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, UIntPtr)	Tenta analisar um intervalo de caracteres UTF-8 em um valor.
TryParse(ReadOnlySpan<Byte>, UIntPtr)	Tenta converter um intervalo de caracteres UTF-8 que contém a representação de cadeia de caracteres de um número em seu inteiro sem sinal equivalente.
TryParse(ReadOnlySpan<Char>, IFormatProvider, UIntPtr)	Tenta analisar uma cadeia de caracteres em um valor.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, UIntPtr)	Converte o intervalo somente leitura de representação de caracteres de um número em um formato específico de cultura e estilo especificado em seu equivalente inteiro nativo sem sinal. Um valor retornado indica se a conversão foi bem-sucedida.
TryParse(ReadOnlySpan<Char>, UIntPtr)	Converte o intervalo somente leitura de representação de caracteres de um número em seu equivalente inteiro nativo sem sinal. Um valor retornado indica se a conversão foi bem-sucedida.
TryParse(String, IFormatProvider, UIntPtr)	Tenta analisar uma cadeia de caracteres em um valor.
TryParse(String, NumberStyles, IFormatProvider, UIntPtr)	Converte a representação de cadeia de caracteres de um número em um formato específico de estilo e cultura especificado em seu equivalente inteiro nativo sem sinal. Um valor retornado indica se a conversão foi bem-sucedida.
TryParse(String, UIntPtr)	Converte a representação de cadeia de caracteres de um número em seu equivalente inteiro nativo sem sinal. Um valor retornado indica se a conversão foi bem-sucedida.

Operadores

Addition(UIntPtr, Int32)	Adiciona um deslocamento a um inteiro sem sinal.
Equality(UIntPtr, UIntPtr)	Determina se duas instâncias especificadas de UIntPtr são iguais.
Explicit(UInt32 to UIntPtr)	Converte o valor de um inteiro sem sinal de 32 bits em um UIntPtr.
Explicit(UInt64 to UIntPtr)	Converte o valor de um inteiro sem sinal de 64 bits em um UIntPtr.
Explicit(UIntPtr to UInt32)	Converte o valor do UIntPtr especificado em um inteiro sem sinal de 32 bits.
Explicit(UIntPtr to UInt64)	Converte o valor do UIntPtr especificado em um inteiro sem sinal de 64 bits.
Explicit(UIntPtr to Void*)	Converte o valor do UIntPtr especificado em um ponteiro para um tipo não especificado. Essa API não é compatível com CLS.
Explicit(Void* to UIntPtr)	Converte o ponteiro especificado em um tipo não especificado em um UIntPtr. Essa API não é compatível com CLS.
Inequality(UIntPtr, UIntPtr)	Determina se duas instâncias especificadas de UIntPtr não são iguais.
Subtraction(UIntPtr, Int32)	Subtrai um deslocamento de um inteiro sem sinal.

Implantações explícitas de interface

IAdditionOperators<UIntPtr,UIntPtr,UIntPtr>.Addition(UIntPtr, UIntPtr)	Adiciona dois valores juntos para calcular sua soma.
IAdditionOperators<UIntPtr,UIntPtr,UIntPtr>.CheckedAddition(UIntPtr, UIntPtr)	Adiciona dois valores juntos para calcular sua soma.
IAdditiveIdentity<UIntPtr,UIntPtr>.AdditiveIdentity	Obtém a identidade aditiva do tipo atual.
IBinaryInteger<UIntPtr>.GetByteCount()	Obtém o número de bytes que serão gravados como parte de TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<UIntPtr>.GetShortestBitLength()	Obtém o comprimento, em bits, da representação complementar dos dois mais curtos do valor atual.
IBinaryInteger<UIntPtr>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, UIntPtr)	Representa um inteiro sem sinal em que a largura do bit é igual a um ponteiro.
IBinaryInteger<UIntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, UIntPtr)	Representa um inteiro sem sinal em que a largura do bit é igual a um ponteiro.
IBinaryInteger<UIntPtr>.TryWriteBigEndian(Span<Byte>, Int32)	Tenta gravar o valor atual, no formato big-endian, em um determinado intervalo.
IBinaryInteger<UIntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)	Tenta gravar o valor atual, no formato little-endian, em um determinado intervalo.
IBinaryNumber<UIntPtr>.AllBitsSet	Obtém uma instância do tipo binário na qual todos os bits são definidos.
IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.BitwiseAnd(UIntPtr, UIntPtr)	Calcula o bit a bit e dois valores.
IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.BitwiseOr(UIntPtr, UIntPtr)	Calcula o bit a bit ou de dois valores.
IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.ExclusiveOr(UIntPtr, UIntPtr)	Calcula o exclusivo ou de dois valores.
IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.OnesComplement(UIntPtr)	Calcula a representação ones-complement de um determinado valor.
IComparisonOperators<UIntPtr,UIntPtr,Boolean>.GreaterThan(UIntPtr, UIntPtr)	Compara dois valores para determinar qual é maior.
IComparisonOperators<UIntPtr,UIntPtr,Boolean>.GreaterThanOrEqual(UIntPtr, UIntPtr)	Compara dois valores para determinar qual é maior ou igual.
IComparisonOperators<UIntPtr,UIntPtr,Boolean>.LessThan(UIntPtr, UIntPtr)	Compara dois valores para determinar qual é menor.
IComparisonOperators<UIntPtr,UIntPtr,Boolean>.LessThanOrEqual(UIntPtr, UIntPtr)	Compara dois valores para determinar qual é menor ou igual.
IDecrementOperators<UIntPtr>.CheckedDecrement(UIntPtr)	Decrementa um valor.
IDecrementOperators<UIntPtr>.Decrement(UIntPtr)	Decrementa um valor.
IDivisionOperators<UIntPtr,UIntPtr,UIntPtr>.Division(UIntPtr, UIntPtr)	Divide um valor por outro para calcular seu quociente.
IIncrementOperators<UIntPtr>.CheckedIncrement(UIntPtr)	Incrementa um valor.
IIncrementOperators<UIntPtr>.Increment(UIntPtr)	Incrementa um valor.
IMinMaxValue<UIntPtr>.MaxValue	Obtém o valor máximo do tipo atual.
IMinMaxValue<UIntPtr>.MinValue	Obtém o valor mínimo do tipo atual.
IModulusOperators<UIntPtr,UIntPtr,UIntPtr>.Modulus(UIntPtr, UIntPtr)	Divide dois valores juntos para calcular seu módulo ou restante.
IMultiplicativeIdentity<UIntPtr,UIntPtr>.MultiplicativeIdentity	Obtém a identidade multiplicativa do tipo atual.
IMultiplyOperators<UIntPtr,UIntPtr,UIntPtr>.CheckedMultiply(UIntPtr, UIntPtr)	Multiplica dois valores juntos para calcular seu produto.
IMultiplyOperators<UIntPtr,UIntPtr,UIntPtr>.Multiply(UIntPtr, UIntPtr)	Multiplica dois valores juntos para calcular seu produto.
INumber<UIntPtr>.CopySign(UIntPtr, UIntPtr)	Copia o sinal de um valor para o sinal de outro valor.
INumber<UIntPtr>.MaxNumber(UIntPtr, UIntPtr)	Compara dois valores com a computação, que é maior e retorna o outro valor se uma entrada é NaN.
INumber<UIntPtr>.MinNumber(UIntPtr, UIntPtr)	Compara dois valores com a computação que é menor e retorna o outro valor se uma entrada é NaN.
INumberBase<UIntPtr>.Abs(UIntPtr)	Calcula o absoluto de um valor.
INumberBase<UIntPtr>.IsCanonical(UIntPtr)	Determina se um valor está em sua representação canônica.
INumberBase<UIntPtr>.IsComplexNumber(UIntPtr)	Determina se um valor representa um número complexo.
INumberBase<UIntPtr>.IsFinite(UIntPtr)	Determina se um valor é finito.
INumberBase<UIntPtr>.IsImaginaryNumber(UIntPtr)	Determina se um valor representa um número imaginário puro.
INumberBase<UIntPtr>.IsInfinity(UIntPtr)	Determina se um valor é infinito.
INumberBase<UIntPtr>.IsInteger(UIntPtr)	Determina se um valor representa um número integral.
INumberBase<UIntPtr>.IsNaN(UIntPtr)	Determina se um valor é NaN.
INumberBase<UIntPtr>.IsNegative(UIntPtr)	Determina se um valor é negativo.
INumberBase<UIntPtr>.IsNegativeInfinity(UIntPtr)	Determina se um valor é infinito negativo.
INumberBase<UIntPtr>.IsNormal(UIntPtr)	Determina se um valor é normal.
INumberBase<UIntPtr>.IsPositive(UIntPtr)	Determina se um valor é positivo.
INumberBase<UIntPtr>.IsPositiveInfinity(UIntPtr)	Determina se um valor é infinito positivo.
INumberBase<UIntPtr>.IsRealNumber(UIntPtr)	Determina se um valor representa um número real.
INumberBase<UIntPtr>.IsSubnormal(UIntPtr)	Determina se um valor é subnormal.
INumberBase<UIntPtr>.IsZero(UIntPtr)	Determina se um valor é zero.
INumberBase<UIntPtr>.MaxMagnitude(UIntPtr, UIntPtr)	Compara dois valores com a computação que é maior.
INumberBase<UIntPtr>.MaxMagnitudeNumber(UIntPtr, UIntPtr)	Compara dois valores com a computação que tem maior magnitude e retorna o outro valor se uma entrada é NaN.
INumberBase<UIntPtr>.MinMagnitude(UIntPtr, UIntPtr)	Compara dois valores com a computação menor.
INumberBase<UIntPtr>.MinMagnitudeNumber(UIntPtr, UIntPtr)	Compara dois valores com a computação que tem a menor magnitude e retorna o outro valor se uma entrada é NaN.
INumberBase<UIntPtr>.One	Obtém o valor 1 para o tipo.
INumberBase<UIntPtr>.Radix	Obtém o radix, ou base, para o tipo.
INumberBase<UIntPtr>.TryConvertFromChecked<TOther>(TOther, UIntPtr)	Representa um inteiro sem sinal em que a largura do bit é igual a um ponteiro.
INumberBase<UIntPtr>.TryConvertFromSaturating<TOther>(TOther, UIntPtr)	Representa um inteiro sem sinal em que a largura do bit é igual a um ponteiro.
INumberBase<UIntPtr>.TryConvertFromTruncating<TOther>(TOther, UIntPtr)	Representa um inteiro sem sinal em que a largura do bit é igual a um ponteiro.
INumberBase<UIntPtr>.TryConvertToChecked<TOther>(UIntPtr, TOther)	Tenta converter uma instância do tipo atual em outro tipo, gerando uma exceção de estouro para quaisquer valores que fiquem fora do intervalo representável do tipo atual.
INumberBase<UIntPtr>.TryConvertToSaturating<TOther>(UIntPtr, TOther)	Tenta converter uma instância do tipo atual em outro tipo, saturando todos os valores que estão fora do intervalo representável do tipo atual.
INumberBase<UIntPtr>.TryConvertToTruncating<TOther>(UIntPtr, TOther)	Tenta converter uma instância do tipo atual em outro tipo, truncando todos os valores que estejam fora do intervalo representável do tipo atual.
INumberBase<UIntPtr>.Zero	Obtém o valor 0 para o tipo.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Popula um objeto SerializationInfo com os dados necessários para serializar o objeto UIntPtr atual.
IShiftOperators<UIntPtr,Int32,UIntPtr>.LeftShift(UIntPtr, Int32)	Desloca um valor deixado por um determinado valor.
IShiftOperators<UIntPtr,Int32,UIntPtr>.RightShift(UIntPtr, Int32)	Desloca um valor para a direita por um determinado valor.
IShiftOperators<UIntPtr,Int32,UIntPtr>.UnsignedRightShift(UIntPtr, Int32)	Desloca um valor para a direita por um determinado valor.
ISubtractionOperators<UIntPtr,UIntPtr,UIntPtr>.CheckedSubtraction(UIntPtr, UIntPtr)	Subtrai dois valores para calcular a diferença.
ISubtractionOperators<UIntPtr,UIntPtr,UIntPtr>.Subtraction(UIntPtr, UIntPtr)	Subtrai dois valores para calcular a diferença.
IUnaryNegationOperators<UIntPtr,UIntPtr>.CheckedUnaryNegation(UIntPtr)	Calcula a negação unária verificada de um valor.
IUnaryNegationOperators<UIntPtr,UIntPtr>.UnaryNegation(UIntPtr)	Calcula a negação unária de um valor.
IUnaryPlusOperators<UIntPtr,UIntPtr>.UnaryPlus(UIntPtr)	Calcula a adição unária de um valor.

Acesso thread-safe

Esse tipo é thread safe.

Confira também

• IntPtr