Ler em inglês

Partilhar via

UIntPtr Estrutura

  • Referência

Definição

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll
Origem:
UIntPtr.cs
Origem:
UIntPtr.cs
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.

C# 
[System.CLSCompliant(false)]
public struct UIntPtr
C# 
[System.CLSCompliant(false)]
public readonly struct UIntPtr : IComparable, IComparable<UIntPtr>, IEquatable<UIntPtr>, IFormattable, System.Runtime.Serialization.ISerializable
C# 
[System.CLSCompliant(false)]
public readonly struct UIntPtr : IComparable, IComparable<UIntPtr>, IEquatable<UIntPtr>, ISpanFormattable, System.Runtime.Serialization.ISerializable
C# 
[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,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
C# 
[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
C# 
[System.CLSCompliant(false)]
public struct UIntPtr : IEquatable<UIntPtr>, System.Runtime.Serialization.ISerializable
C# 
[System.CLSCompliant(false)]
public readonly struct UIntPtr : IEquatable<UIntPtr>, System.Runtime.Serialization.ISerializable
C# 
[System.CLSCompliant(false)]
[System.Serializable]
public struct UIntPtr : System.Runtime.Serialization.ISerializable
C# 
[System.CLSCompliant(false)]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct UIntPtr : System.Runtime.Serialization.ISerializable
C# 
[System.CLSCompliant(false)]
public struct UIntPtr : System.Runtime.Serialization.ISerializable
Herança
Object
ValueType
UIntPtr
Atributos
CLSCompliantAttribute SerializableAttribute ComVisibleAttribute
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.
IEquatable<UIntPtr>.Equals(UIntPtr)

Retorna um valor que indica se essa instância é igual a outro inteiro sem sinal.
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>.MultiplyAddEstimate(UIntPtr, UIntPtr, UIntPtr)

Calcula uma estimativa de (left * right) + addend.
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.

Aplica-se a

Produto Versões
net-7.0 net-7.0

Acesso thread-safe

Esse tipo é thread safe.

Confira também