UIntPtr Structure

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Important

Cette API n’est pas conforme CLS.

Représente un entier non signé où la largeur du bit est identique à un pointeur.

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

Héritage: Object

ValueType
UIntPtr

Attributs: CLSCompliantAttribute SerializableAttribute ComVisibleAttribute

Implémente: 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>

Remarques

Le UIntPtr type est conçu pour être un entier dont la taille est identique à un pointeur. Autrement dit, une instance de ce type devrait être de 32 bits dans un processus 32 bits et 64 bits dans un processus 64 bits.

Le UIntPtr type peut être utilisé par les langages qui prennent en charge les pointeurs, et comme moyen commun de faire référence aux données entre les langages qui ne prennent pas en charge les pointeurs. UIntPtr les objets peuvent également être utilisés pour contenir des handles.

Notes

L’utilisation UIntPtr en tant que pointeur ou handle est sujette aux erreurs et non sécurisée. Il s’agit simplement d’un type entier qui peut être utilisé comme format d’échange pour les pointeurs et les handles en raison de la même taille. En dehors des exigences d’échange spécifiques, telles que le passage de données à un langage qui ne prend pas en charge les pointeurs, un pointeur correctement typé doit être utilisé pour représenter des pointeurs et SafeHandle doit être utilisé pour représenter des handles.

Ce type implémente le ISerializable. Dans .NET 5 et versions ultérieures, ce type implémente également les IFormattable interfaces. Dans .NET 7 et versions ultérieures, ce type implémente également les interfaces, et IUnsignedNumber<TSelf> les IBinaryInteger<TSelf>. IMinMaxValue<TSelf>

En C# à partir de la version 9.0, vous pouvez utiliser le type intégré nuint pour définir des entiers de taille native. Ce type est représenté par le UIntPtr type en interne et fournit des opérations et des conversions appropriées pour les types entiers. Pour plus d’informations, consultez les types nint et nuint.

En C# à partir de la version 11 et lorsque vous ciblez le runtime .NET 7 ou ultérieur, nuint il s’agit d’un alias pour UIntPtr la même façon que uint pour UInt32laquelle il s’agit d’un alias .

Constructeurs

UIntPtr(UInt32)	Initialise une nouvelle instance de la structure à l’aide UIntPtr de l’entier non signé 32 bits spécifié.
UIntPtr(UInt64)	Initialise une nouvelle instance d’utilisation de UIntPtr l’entier non signé 64 bits spécifié.
UIntPtr(Void*)	Initialise une nouvelle instance de UIntPtr à l'aide du pointeur spécifié vers un type non spécifié.

Champs

Zero	Champ en lecture seule qui représente un entier non signé qui a été initialisé à zéro.

Propriétés

MaxValue	Représente la plus grande valeur possible de UIntPtr.
MinValue	Représente la plus petite valeur possible de UIntPtr.
Size	Obtient la taille de cette instance.

Méthodes

Add(UIntPtr, Int32)	Ajoute un décalage à un entier non signé.
Clamp(UIntPtr, UIntPtr, UIntPtr)	Supprime une valeur à une valeur minimale et maximale inclusive.
CompareTo(Object)	Compare l'instance actuelle à un autre objet du même type et retourne un entier qui indique si l'instance actuelle précède ou suit un autre objet ou se trouve à la même position que ce dernier dans l'ordre de tri.
CompareTo(UIntPtr)	Compare l'instance actuelle à un autre objet du même type et retourne un entier qui indique si l'instance actuelle précède ou suit un autre objet ou se trouve à la même position que ce dernier dans l'ordre de tri.
DivRem(UIntPtr, UIntPtr)	Calcule le quotient et le reste de deux valeurs.
Equals(Object)	Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.
Equals(UIntPtr)	Indique si l'objet actuel est égal à un autre objet du même type.
GetHashCode()	Retourne le code de hachage de cette instance.
IsEvenInteger(UIntPtr)	Détermine si une valeur représente un nombre même intégral.
IsOddInteger(UIntPtr)	Détermine si une valeur représente un nombre intégral impair.
IsPow2(UIntPtr)	Détermine si une valeur est une puissance de deux.
LeadingZeroCount(UIntPtr)	Calcule le nombre de zéros de début dans une valeur.
Log2(UIntPtr)	Calcule le journal2 d’une valeur.
Max(UIntPtr, UIntPtr)	Compare deux valeurs au calcul qui est supérieur.
Min(UIntPtr, UIntPtr)	Compare deux valeurs au calcul, ce qui est inférieur.
Parse(ReadOnlySpan<Char>, IFormatProvider)
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convertit l’étendue en lecture seule de la représentation de caractères d’un nombre dans un style éventuellement spécifié et le format spécifique à la culture éventuellement spécifié en son équivalent entier natif non signé.
Parse(String)	Convertit la représentation sous forme de chaîne d’un nombre en entier natif non signé équivalent.
Parse(String, IFormatProvider)	Convertit la représentation sous forme de chaîne d’un nombre dans un format spécifique à la culture spécifié en son équivalent entier natif non signé.
Parse(String, NumberStyles)	Convertit la représentation sous forme de chaîne d’un nombre dans un style spécifié en équivalent entier natif non signé.
Parse(String, NumberStyles, IFormatProvider)	Convertit la représentation sous forme de chaîne d’un nombre dans un style spécifié et un format spécifique à la culture en son équivalent entier natif non signé.
PopCount(UIntPtr)	Calcule le nombre de bits définis dans une valeur.
RotateLeft(UIntPtr, Int32)	Fait pivoter une valeur à gauche par une quantité donnée.
RotateRight(UIntPtr, Int32)	Fait pivoter une valeur à droite d’une quantité donnée.
Sign(UIntPtr)	Calcule le signe d’une valeur.
Subtract(UIntPtr, Int32)	Soustrait un décalage d’un entier non signé.
ToPointer()	Convertit la valeur de cette instance en pointeur vers un type non spécifié.
ToString()	Convertit la valeur numérique de cette instance en sa représentation équivalente sous forme de chaîne.
ToString(IFormatProvider)	Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente à l'aide du format spécifié et des informations de format spécifiques à la culture.
ToString(String)	Convertit la valeur numérique de cette instance en sa représentation sous forme de chaîne équivalente en utilisant le format spécifié.
ToString(String, IFormatProvider)	Met en forme la valeur de l’instance actuelle en utilisant le format spécifié.
ToUInt32()	Convertit la valeur de cette instance en entier 32 bits non signé.
ToUInt64()	Convertit la valeur de cette instance en entier non signé 64 bits.
TrailingZeroCount(UIntPtr)	Calcule le nombre de zéros de fin dans une valeur.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tente de mettre en forme la valeur de l’instance actuelle dans l’étendue fournie de caractères.
TryParse(ReadOnlySpan<Char>, IFormatProvider, UIntPtr)
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, UIntPtr)	Convertit l’étendue en lecture seule de la représentation de caractères d’un nombre dans un style et un format spécifique à la culture spécifiés en son équivalent entier natif non signé. Une valeur de retour indique si la conversion a réussi.
TryParse(ReadOnlySpan<Char>, UIntPtr)	Convertit l’étendue en lecture seule de la représentation de caractères d’un nombre en son équivalent entier natif non signé. Une valeur de retour indique si la conversion a réussi.
TryParse(String, IFormatProvider, UIntPtr)
TryParse(String, NumberStyles, IFormatProvider, UIntPtr)	Convertit la représentation sous forme de chaîne d’un nombre dans un style spécifié et un format spécifique à la culture en son équivalent entier natif non signé. Une valeur de retour indique si la conversion a réussi.
TryParse(String, UIntPtr)	Convertit la représentation sous forme de chaîne d’un nombre en son équivalent entier natif non signé. Une valeur de retour indique si la conversion a réussi.

Opérateurs

Addition(UIntPtr, Int32)	Ajoute un décalage à un entier non signé.
Equality(UIntPtr, UIntPtr)	Détermine si deux instances spécifiées de UIntPtr sont égales.
Explicit(UInt32 to UIntPtr)	Convertit la valeur d'un entier 32 bits non signé en UIntPtr.
Explicit(UInt64 to UIntPtr)	Convertit la valeur d’un entier non signé 64 bits en UIntPtr.
Explicit(UIntPtr to UInt32)	Convertit la valeur du UIntPtr spécifié en entier 32 bits non signé.
Explicit(UIntPtr to UInt64)	Convertit la valeur du UIntPtr spécifié en entier non signé 64 bits.
Explicit(UIntPtr to Void*)	Convertit la valeur du UIntPtr spécifié en pointeur de type non spécifié. Cette API n'est pas conforme CLS.
Explicit(Void* to UIntPtr)	Convertit le pointeur spécifié vers un type non spécifié en UIntPtr. Cette API n'est pas conforme CLS.
Inequality(UIntPtr, UIntPtr)	Détermine si deux instances spécifiées de UIntPtr ne sont pas égales.
Subtraction(UIntPtr, Int32)	Soustrait un décalage d’un entier non signé.

Implémentations d’interfaces explicites

IBinaryInteger<UIntPtr>.GetByteCount()	Obtient le nombre d’octets qui seront écrits dans le cadre de TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<UIntPtr>.GetShortestBitLength()	Obtient la longueur, en bits, de la représentation complémentaire des deux plus courtes de la valeur actuelle.
IBinaryInteger<UIntPtr>.TryWriteBigEndian(Span<Byte>, Int32)	Tente d’écrire la valeur actuelle, au format big-endian, dans une étendue donnée.
IBinaryInteger<UIntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)	Tente d’écrire la valeur actuelle, au format little-endian, dans une étendue donnée.
IEquatable<UIntPtr>.Equals(UIntPtr)	Retourne une valeur qui indique si cette instance est égale à un autre entier non signé.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Remplit un objet SerializationInfo des données nécessaires à la sérialisation de l'objet UIntPtr actuel.

S’applique à

Cohérence de thread

Ce type est thread-safe.

Voir aussi

IntPtr