UIntPtr Struct

Definizione

Importante

Questa API non è conforme a CLS.

Rappresenta un intero senza segno in cui la larghezza del bit corrisponde a un puntatore.

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, 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
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
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,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)]
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, 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 IShiftOperators<unativeint, int, unativeint>
    interface IMinMaxValue<unativeint>
    interface IUnsignedNumber<unativeint>
    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, 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
[<System.CLSCompliant(false)>]
type unativeint = struct
    interface IFormattable
    interface IParsable<unativeint>
    interface ISpanFormattable
    interface ISpanParsable<unativeint>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<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 IShiftOperators<unativeint, int, 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, 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)
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)
Public Structure UIntPtr
Implements IEquatable(Of UIntPtr), ISerializable
Public Structure UIntPtr
Implements ISerializable
Ereditarietà
UIntPtr
Attributi
Implementazioni
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>

Commenti

Il UIntPtr tipo è progettato per essere un numero intero la cui dimensione è uguale a un puntatore. Ovvero, un'istanza di questo tipo dovrebbe essere a 32 bit in un processo a 32 bit e a 64 bit in un processo a 64 bit.

Il UIntPtr tipo può essere usato dalle lingue che supportano puntatori e come mezzo comune per fare riferimento ai dati tra lingue che eseguono e non supportano puntatori. UIntPtr gli oggetti possono essere utilizzati anche per contenere handle.

Nota

L'uso UIntPtr come puntatore o handle è soggetto a errori e non sicuro. Si tratta semplicemente di un tipo integer che può essere usato come formato di interscambio per puntatori e handle a causa della stessa dimensione. Al di fuori dei requisiti di interscambio specifici, ad esempio per il passaggio di dati a un linguaggio che non supporta puntatori, è necessario usare un puntatore tipizzato correttamente per rappresentare i puntatori e SafeHandle deve essere usato per rappresentare gli handle.

Questo tipo implementa .ISerializable In .NET 5 e versioni successive questo tipo implementa anche le IFormattable interfacce. In .NET 7 e versioni successive questo tipo implementa anche le IBinaryInteger<TSelf>interfacce , IMinMaxValue<TSelf>e IUnsignedNumber<TSelf> .

In C# a partire dalla versione 9.0 è possibile usare il tipo predefinito nuint per definire numeri interi di dimensioni native. Questo tipo è rappresentato dal UIntPtr tipo internamente e fornisce operazioni e conversioni appropriate per i tipi integer. Per altre informazioni, vedere tipi nint e nuint.

In C# a partire dalla versione 11 e quando la destinazione è il runtime .NET 7 o versione successiva, nuint è un alias per UIntPtr nello stesso modo in cui uint è un alias per UInt32.

Costruttori

UIntPtr(UInt32)

Inizializza una nuova istanza della struttura usando l'intero UIntPtr senza segno a 32 bit specificato.

UIntPtr(UInt64)

Inizializza una nuova istanza di UIntPtr usando l'intero senza segno a 64 bit specificato.

UIntPtr(Void*)

Inizializza una nuova istanza di UIntPtr usando il puntatore specificato a un tipo non specificato.

Campi

Zero

Campo di sola lettura che rappresenta un intero senza segno inizializzato su zero.

Proprietà

MaxValue

Rappresenta il valore massimo possibile di UIntPtr.

MinValue

Rappresenta il valore più piccolo possibile di UIntPtr.

Size

Ottiene le dimensioni dell'istanza.

Metodi

Add(UIntPtr, Int32)

Aggiunge un offset a un intero senza segno.

Clamp(UIntPtr, UIntPtr, UIntPtr)

Blocca un valore a un valore minimo e massimo inclusivo.

CompareTo(Object)

Confronta l'istanza corrente con un altro oggetto dello stesso tipo e restituisce un intero che indica se l'istanza corrente precede, segue o si trova nella stessa posizione dell'altro oggetto all'interno dell'ordinamento.

CompareTo(UIntPtr)

Confronta l'istanza corrente con un altro oggetto dello stesso tipo e restituisce un intero che indica se l'istanza corrente precede, segue o si trova nella stessa posizione dell'altro oggetto all'interno dell'ordinamento.

CreateChecked<TOther>(TOther)

Crea un'istanza del tipo corrente da un valore, generando un'eccezione di overflow per tutti i valori che rientrano all'esterno dell'intervallo rappresentabile del tipo corrente.

CreateSaturating<TOther>(TOther)

Crea un'istanza del tipo corrente da un valore, saturazione di tutti i valori che rientrano all'esterno dell'intervallo rappresentabile del tipo corrente.

CreateTruncating<TOther>(TOther)

Crea un'istanza del tipo corrente da un valore, troncando tutti i valori che rientrano all'esterno dell'intervallo rappresentabile del tipo corrente.

DivRem(UIntPtr, UIntPtr)

Calcola il quoziente e il resto di due valori.

Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.

Equals(UIntPtr)

Indica se l'oggetto corrente è uguale a un altro oggetto dello stesso tipo.

GetHashCode()

Restituisce il codice hash per l'istanza.

IsEvenInteger(UIntPtr)

Determina se un valore rappresenta un numero integrale pari.

IsOddInteger(UIntPtr)

Determina se un valore rappresenta un numero integrale dispari.

IsPow2(UIntPtr)

Determina se un valore è una potenza di due.

LeadingZeroCount(UIntPtr)

Calcola il numero di zero iniziali in un valore.

Log2(UIntPtr)

Calcola il log2 di un valore.

Max(UIntPtr, UIntPtr)

Confronta due valori per calcolare che è maggiore.

Min(UIntPtr, UIntPtr)

Confronta due valori per calcolare che è minore.

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Analizza un intervallo di caratteri UTF-8 in un valore.

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Analizza un intervallo di caratteri UTF-8 in un valore.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analizza un intervallo di caratteri in un valore.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Converte l'intervallo di caratteri di sola lettura di un numero in stile facoltativamente specificato e facoltativamente specificato in formato specifico delle impostazioni cultura nel relativo intero nativo senza segno.

Parse(String)

Converte la rappresentazione di stringa di un numero nell'intero nativo senza segno equivalente.

Parse(String, IFormatProvider)

Converte la rappresentazione stringa di un numero in un formato specifico delle impostazioni cultura specificato nell'intero nativo senza segno equivalente.

Parse(String, NumberStyles)

Converte la rappresentazione di stringa di un numero in uno stile specificato nell'equivalente intero senza segno a 64 bit.

Parse(String, NumberStyles, IFormatProvider)

Converte la rappresentazione di stringa di un numero in uno stile e un formato delle impostazioni cultura specifici nell'equivalente intero nativo senza segno.

PopCount(UIntPtr)

Calcola il numero di bit impostati in un valore.

RotateLeft(UIntPtr, Int32)

Ruota un valore sinistro da una determinata quantità.

RotateRight(UIntPtr, Int32)

Ruota un valore a destra in base a una determinata quantità.

Sign(UIntPtr)

Calcola il segno di un valore.

Subtract(UIntPtr, Int32)

Sottrae un offset da un intero senza segno.

ToPointer()

Converte il valore dell'istanza in un puntatore a un tipo non specificato.

ToString()

Converte il valore numerico dell'istanza nella rappresentazione di stringa equivalente.

ToString(IFormatProvider)

Converte il valore numerico dell'istanza nella rappresentazione di stringa equivalente usando il formato specificato e le informazioni di formattazione specifiche delle impostazioni cultura.

ToString(String)

Converte il valore numerico di questa istanza nell'equivalente rappresentazione di stringa usando il formato specificato.

ToString(String, IFormatProvider)

Formatta il valore dell'istanza corrente usando il formato specificato.

ToUInt32()

Consente di convertire il valore dell'istanza in un intero senza segno di 32 bit.

ToUInt64()

Converte il valore di questa istanza in un intero senza segno a 64 bit.

TrailingZeroCount(UIntPtr)

Calcola il numero di zeri finali in un valore.

TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Tenta di formattare il valore dell'istanza corrente come UTF-8 nell'intervallo di byte specificato.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Tenta di formattare il valore dell'istanza corrente nell'intervallo di caratteri specificato.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, UIntPtr)

Tenta di analizzare un intervallo di caratteri UTF-8 in un valore.

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

Tenta di analizzare un intervallo di caratteri UTF-8 in un valore.

TryParse(ReadOnlySpan<Byte>, UIntPtr)

Tenta di convertire un intervallo di caratteri UTF-8 contenente la rappresentazione di stringa di un numero nell'equivalente intero senza segno.

TryParse(ReadOnlySpan<Char>, IFormatProvider, UIntPtr)

Tenta di analizzare una stringa in un valore.

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

Converte l'intervallo di sola lettura della rappresentazione di caratteri di un numero in uno stile specificato e nel formato specifico delle impostazioni cultura nell'equivalente intero nativo senza segno. Un valore restituito indica se la conversione è riuscita.

TryParse(ReadOnlySpan<Char>, UIntPtr)

Converte l'intervallo di caratteri di sola lettura di un numero nell'equivalente intero nativo senza segno. Un valore restituito indica se la conversione è riuscita.

TryParse(String, IFormatProvider, UIntPtr)

Tenta di analizzare una stringa in un valore.

TryParse(String, NumberStyles, IFormatProvider, UIntPtr)

Converte la rappresentazione di stringa di un numero in uno stile e un formato delle impostazioni cultura specifici nell'equivalente intero nativo senza segno. Un valore restituito indica se la conversione è riuscita.

TryParse(String, UIntPtr)

Converte la rappresentazione di stringa di un numero nell'intero nativo senza segno equivalente. Un valore restituito indica se la conversione è riuscita.

Operatori

Addition(UIntPtr, Int32)

Aggiunge un offset a un intero senza segno.

Equality(UIntPtr, UIntPtr)

Determina se due istanze specificate dell'oggetto UIntPtr sono uguali.

Explicit(UInt32 to UIntPtr)

Consente di convertire il valore di un intero senza segno a 32 bit in un oggetto UIntPtr.

Explicit(UInt64 to UIntPtr)

Converte il valore di un intero senza segno a 64 bit in un oggetto UIntPtr.

Explicit(UIntPtr to UInt32)

Consente di convertire il valore dell'oggetto UIntPtr specificato in un intero senza segno a 32 bit.

Explicit(UIntPtr to UInt64)

Converte il valore dell'oggetto UIntPtr specificato in un intero senza segno a 64 bit.

Explicit(UIntPtr to Void*)

Converte il valore dell'oggetto UIntPtr specificato in un puntatore a un tipo non specificato.

Questa API non è conforme a CLS.

Explicit(Void* to UIntPtr)

Converte il puntatore specificato per un tipo non specificato in un oggetto UIntPtr.

Questa API non è conforme a CLS.

Inequality(UIntPtr, UIntPtr)

Determina se due istanze specificate dell'oggetto UIntPtr non sono uguali.

Subtraction(UIntPtr, Int32)

Sottrae un offset da un intero senza segno.

Implementazioni dell'interfaccia esplicita

IAdditionOperators<UIntPtr,UIntPtr,UIntPtr>.Addition(UIntPtr, UIntPtr)

Aggiunge due valori insieme per calcolare la somma.

IAdditionOperators<UIntPtr,UIntPtr,UIntPtr>.CheckedAddition(UIntPtr, UIntPtr)

Aggiunge due valori insieme per calcolare la somma.

IAdditiveIdentity<UIntPtr,UIntPtr>.AdditiveIdentity

Ottiene l'identità additiva del tipo corrente.

IBinaryInteger<UIntPtr>.GetByteCount()

Ottiene il numero di byte che verranno scritti come parte di TryWriteLittleEndian(Span<Byte>, Int32).

IBinaryInteger<UIntPtr>.GetShortestBitLength()

Ottiene la lunghezza, in bit, della rappresentazione di complemento più breve del valore corrente.

IBinaryInteger<UIntPtr>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, UIntPtr)

Rappresenta un intero senza segno in cui la larghezza del bit corrisponde a un puntatore.

IBinaryInteger<UIntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, UIntPtr)

Rappresenta un intero senza segno in cui la larghezza del bit corrisponde a un puntatore.

IBinaryInteger<UIntPtr>.TryWriteBigEndian(Span<Byte>, Int32)

Prova a scrivere il valore corrente, in formato big-endian, in un determinato intervallo.

IBinaryInteger<UIntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)

Tenta di scrivere il valore corrente, in formato little-endian, in un determinato intervallo.

IBinaryNumber<UIntPtr>.AllBitsSet

Ottiene un'istanza del tipo binario in cui vengono impostati tutti i bit.

IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.BitwiseAnd(UIntPtr, UIntPtr)

Calcola i valori bit per bit e di due valori.

IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.BitwiseOr(UIntPtr, UIntPtr)

Calcola i valori bit per bit o di due valori.

IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.ExclusiveOr(UIntPtr, UIntPtr)

Calcola l'esclusivo o di due valori.

IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.OnesComplement(UIntPtr)

Calcola la rappresentazione di complemento di un determinato valore.

IComparisonOperators<UIntPtr,UIntPtr,Boolean>.GreaterThan(UIntPtr, UIntPtr)

Confronta due valori per determinare quale è maggiore.

IComparisonOperators<UIntPtr,UIntPtr,Boolean>.GreaterThanOrEqual(UIntPtr, UIntPtr)

Confronta due valori per determinare quale è maggiore o uguale.

IComparisonOperators<UIntPtr,UIntPtr,Boolean>.LessThan(UIntPtr, UIntPtr)

Confronta due valori per determinare quali sono meno.

IComparisonOperators<UIntPtr,UIntPtr,Boolean>.LessThanOrEqual(UIntPtr, UIntPtr)

Confronta due valori per determinare quale è minore o uguale.

IDecrementOperators<UIntPtr>.CheckedDecrement(UIntPtr)

Decrementa un valore.

IDecrementOperators<UIntPtr>.Decrement(UIntPtr)

Decrementa un valore.

IDivisionOperators<UIntPtr,UIntPtr,UIntPtr>.Division(UIntPtr, UIntPtr)

Divide un valore da un altro per calcolare il quoziente.

IEquatable<UIntPtr>.Equals(UIntPtr)

Restituisce un valore che indica se questa istanza è uguale a un altro intero senza segno.

IIncrementOperators<UIntPtr>.CheckedIncrement(UIntPtr)

Incrementa un valore.

IIncrementOperators<UIntPtr>.Increment(UIntPtr)

Incrementa un valore.

IMinMaxValue<UIntPtr>.MaxValue

Ottiene il valore massimo del tipo corrente.

IMinMaxValue<UIntPtr>.MinValue

Ottiene il valore minimo del tipo corrente.

IModulusOperators<UIntPtr,UIntPtr,UIntPtr>.Modulus(UIntPtr, UIntPtr)

Divide due valori insieme per calcolare il modulo o il resto.

IMultiplicativeIdentity<UIntPtr,UIntPtr>.MultiplicativeIdentity

Ottiene l'identità moltiplicativa del tipo corrente.

IMultiplyOperators<UIntPtr,UIntPtr,UIntPtr>.CheckedMultiply(UIntPtr, UIntPtr)

Moltiplica due valori insieme per calcolare il prodotto.

IMultiplyOperators<UIntPtr,UIntPtr,UIntPtr>.Multiply(UIntPtr, UIntPtr)

Moltiplica due valori insieme per calcolare il prodotto.

INumber<UIntPtr>.CopySign(UIntPtr, UIntPtr)

Copia il segno di un valore nel segno di un altro valore.

INumber<UIntPtr>.MaxNumber(UIntPtr, UIntPtr)

Confronta due valori per calcolare che è maggiore e restituisce l'altro valore se un input è NaN.

INumber<UIntPtr>.MinNumber(UIntPtr, UIntPtr)

Confronta due valori per calcolare che è minore e restituisce l'altro valore se un input è NaN.

INumberBase<UIntPtr>.Abs(UIntPtr)

Calcola l'assoluto di un valore.

INumberBase<UIntPtr>.IsCanonical(UIntPtr)

Determina se un valore è nella relativa rappresentazione canonica.

INumberBase<UIntPtr>.IsComplexNumber(UIntPtr)

Determina se un valore rappresenta un numero complesso.

INumberBase<UIntPtr>.IsFinite(UIntPtr)

Determina se un valore è finito.

INumberBase<UIntPtr>.IsImaginaryNumber(UIntPtr)

Determina se un valore rappresenta un numero immaginario puro.

INumberBase<UIntPtr>.IsInfinity(UIntPtr)

Determina se un valore è infinito.

INumberBase<UIntPtr>.IsInteger(UIntPtr)

Determina se un valore rappresenta un numero integrale.

INumberBase<UIntPtr>.IsNaN(UIntPtr)

Determina se un valore è NaN.

INumberBase<UIntPtr>.IsNegative(UIntPtr)

Determina se un valore è negativo.

INumberBase<UIntPtr>.IsNegativeInfinity(UIntPtr)

Determina se un valore è infinito negativo.

INumberBase<UIntPtr>.IsNormal(UIntPtr)

Determina se un valore è normale.

INumberBase<UIntPtr>.IsPositive(UIntPtr)

Determina se un valore è positivo.

INumberBase<UIntPtr>.IsPositiveInfinity(UIntPtr)

Determina se un valore è infinito positivo.

INumberBase<UIntPtr>.IsRealNumber(UIntPtr)

Determina se un valore rappresenta un numero reale.

INumberBase<UIntPtr>.IsSubnormal(UIntPtr)

Determina se un valore è sottonormaale.

INumberBase<UIntPtr>.IsZero(UIntPtr)

Determina se un valore è zero.

INumberBase<UIntPtr>.MaxMagnitude(UIntPtr, UIntPtr)

Confronta due valori con il calcolo maggiore.

INumberBase<UIntPtr>.MaxMagnitudeNumber(UIntPtr, UIntPtr)

Confronta due valori con il calcolo che ha la grandezza maggiore e restituisce l'altro valore se un input è NaN.

INumberBase<UIntPtr>.MinMagnitude(UIntPtr, UIntPtr)

Confronta due valori con il calcolo minore.

INumberBase<UIntPtr>.MinMagnitudeNumber(UIntPtr, UIntPtr)

Confronta due valori con il calcolo con la grandezza minore e restituendo l'altro valore se un input è NaN.

INumberBase<UIntPtr>.One

Ottiene il valore 1 per il tipo.

INumberBase<UIntPtr>.Radix

Ottiene il radix, o base, per il tipo .

INumberBase<UIntPtr>.TryConvertFromChecked<TOther>(TOther, UIntPtr)

Rappresenta un intero senza segno in cui la larghezza del bit corrisponde a un puntatore.

INumberBase<UIntPtr>.TryConvertFromSaturating<TOther>(TOther, UIntPtr)

Rappresenta un intero senza segno in cui la larghezza del bit corrisponde a un puntatore.

INumberBase<UIntPtr>.TryConvertFromTruncating<TOther>(TOther, UIntPtr)

Rappresenta un intero senza segno in cui la larghezza del bit corrisponde a un puntatore.

INumberBase<UIntPtr>.TryConvertToChecked<TOther>(UIntPtr, TOther)

Tenta di convertire un'istanza del tipo corrente in un altro tipo, generando un'eccezione di overflow per tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente.

INumberBase<UIntPtr>.TryConvertToSaturating<TOther>(UIntPtr, TOther)

Tenta di convertire un'istanza del tipo corrente in un altro tipo, saturazione di tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente.

INumberBase<UIntPtr>.TryConvertToTruncating<TOther>(UIntPtr, TOther)

Tenta di convertire un'istanza del tipo corrente in un altro tipo, troncando tutti i valori che non rientrano nell'intervallo rappresentabile del tipo corrente.

INumberBase<UIntPtr>.Zero

Ottiene il valore 0 per il tipo.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Compila un oggetto SerializationInfo con i dati necessari per serializzare l'oggetto UIntPtr corrente.

IShiftOperators<UIntPtr,Int32,UIntPtr>.LeftShift(UIntPtr, Int32)

Sposta un valore lasciato da un determinato importo.

IShiftOperators<UIntPtr,Int32,UIntPtr>.RightShift(UIntPtr, Int32)

Sposta un valore a destra in base a una determinata quantità.

IShiftOperators<UIntPtr,Int32,UIntPtr>.UnsignedRightShift(UIntPtr, Int32)

Sposta un valore a destra in base a una determinata quantità.

ISubtractionOperators<UIntPtr,UIntPtr,UIntPtr>.CheckedSubtraction(UIntPtr, UIntPtr)

Sottrae due valori per calcolare la differenza.

ISubtractionOperators<UIntPtr,UIntPtr,UIntPtr>.Subtraction(UIntPtr, UIntPtr)

Sottrae due valori per calcolare la differenza.

IUnaryNegationOperators<UIntPtr,UIntPtr>.CheckedUnaryNegation(UIntPtr)

Calcola la negazione unaria controllata di un valore.

IUnaryNegationOperators<UIntPtr,UIntPtr>.UnaryNegation(UIntPtr)

Calcola la negazione unaria di un valore.

IUnaryPlusOperators<UIntPtr,UIntPtr>.UnaryPlus(UIntPtr)

Calcola il segno più unario di un valore.

Si applica a

Thread safety

Questo tipo è thread-safe.

Vedi anche