UIntPtr Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Source:

UIntPtr.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Stellt eine ganze Zahl ohne Vorzeichen dar, bei der die Bitbreite mit einem Zeiger übereinstimmt.

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)

Vererbung

Object

ValueType

UIntPtr

Attribute

CLSCompliantAttribute

Implementiert

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>

Hinweise

Der UIntPtr Typ ist so konzipiert, dass es sich um eine ganze Zahl handelt, deren Größe mit einem Zeiger identisch ist. Das heißt, eine instance dieses Typs wird voraussichtlich 32-Bits in einem 32-Bit-Prozess und 64 Bit in einem 64-Bit-Prozess sein.

Der UIntPtr Typ kann von Sprachen verwendet werden, die Zeiger unterstützen, und als gängiges Mittel zum Verweisen auf Daten zwischen Sprachen, die Zeiger unterstützen und nicht. UIntPtr -Objekte können auch zum Halten von Handles verwendet werden.

Hinweis

Die Verwendung UIntPtr als Zeiger oder Handle ist fehleranfällig und unsicher. Es ist einfach ein ganzzahliger Typ, der aufgrund der gleichen Größe als Austauschformat für Zeiger und Handles verwendet werden kann. Außerhalb bestimmter Austauschanforderungen, z. B. für das Übergeben von Daten an eine Sprache, die Zeiger nicht unterstützt, sollte ein richtig eingegebener Zeiger verwendet werden, um Zeiger darzustellen und SafeHandle zum Darstellen von Handles verwendet werden.

Dieser Typ implementiert das ISerializable. In .NET 5 und höheren Versionen implementiert dieser Typ auch die IFormattable Schnittstellen. In .NET 7 und höheren Versionen implementiert dieser Typ auch die IBinaryInteger<TSelf>Schnittstellen , IMinMaxValue<TSelf>und IUnsignedNumber<TSelf> .

In C# ab Version 9.0 können Sie den integrierten nuint Typ verwenden, um ganze Zahlen in nativer Größe zu definieren. Dieser Typ wird intern durch den UIntPtr Typ dargestellt und stellt Vorgänge und Konvertierungen bereit, die für ganzzahlige Typen geeignet sind. Weitere Informationen finden Sie unter nint- und nuint-Typen.

In C# ab Version 11 und beim Ziel der .NET 7- oder höher-Runtime nuint ist ein Alias für UIntPtr auf die gleiche Weise wie uint ein Alias für UInt32.

Konstruktoren

UIntPtr(UInt32)	Initialisiert eine neue instance der UIntPtr Struktur unter Verwendung der angegebenen 32-Bit-Ganzzahl ohne Vorzeichen.
UIntPtr(UInt64)	Initialisiert eine neue instance der Verwendung der UIntPtr angegebenen 64-Bit-Ganzzahl ohne Vorzeichen.
UIntPtr(Void*)	Initialisiert eine neue Instanz von UIntPtr mit dem angegebenen Zeiger auf einen nicht angegebenen Typ.

Felder

Zero	Ein schreibgeschütztes Feld, das eine ganze Zahl ohne Vorzeichen darstellt, die mit null initialisiert wurde.

Eigenschaften

MaxValue	Stellt den größtmöglichen Wert von UIntPtr dar.
MinValue	Stellt den kleinstmöglichen Wert von UIntPtr dar.
Size	Ruft die Größe dieser Instanz ab.

Methoden

Add(UIntPtr, Int32)	Fügt einer ganzzahligen Zahl ohne Vorzeichen einen Offset hinzu.
Clamp(UIntPtr, UIntPtr, UIntPtr)	Klemmt einen Wert auf einen inklusiven Minimal- und Maximalwert.
CompareTo(Object)	Vergleicht die aktuelle Instanz mit einem anderen Objekt vom selben Typ und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz in der Sortierreihenfolge vor oder nach dem anderen Objekt oder an derselben Position auftritt.
CompareTo(UIntPtr)	Vergleicht die aktuelle Instanz mit einem anderen Objekt vom selben Typ und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz in der Sortierreihenfolge vor oder nach dem anderen Objekt oder an derselben Position auftritt.
CreateChecked<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem Wert und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateSaturating<TOther>(TOther)	Erstellt einen instance des aktuellen Typs aus einem Wert, der alle Werte überlastt, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateTruncating<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem Wert und schneidet alle Werte ab, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
DivRem(UIntPtr, UIntPtr)	Berechnet den Quotienten und den Rest von zwei Werten.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.
Equals(UIntPtr)	Gibt an, ob das aktuelle Objekt gleich einem anderen Objekt des gleichen Typs ist.
GetHashCode()	Gibt den Hashcode für diese Instanz zurück.
IsEvenInteger(UIntPtr)	Bestimmt, ob ein Wert eine gerade Integralzahl darstellt.
IsOddInteger(UIntPtr)	Bestimmt, ob ein Wert eine ungerade Integralzahl darstellt.
IsPow2(UIntPtr)	Bestimmt, ob ein Wert eine Macht von zwei ist.
LeadingZeroCount(UIntPtr)	Berechnet die Anzahl der führenden Nullen in einem Wert.
Log2(UIntPtr)	Berechnet das protokoll2 eines Werts.
Max(UIntPtr, UIntPtr)	Vergleicht zwei Werte mit der Berechnung, die größer ist.
Min(UIntPtr, UIntPtr)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analysiert eine Spanne von UTF-8-Zeichen in einen Wert.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analysiert eine Spanne von UTF-8-Zeichen in einen Wert.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert die schreibgeschützte Spanne der Zeichendarstellung einer Zahl in optional angegebenem Format und optional angegebenem kulturspezifischem Format in die native Integer-Entsprechung ohne Vorzeichen.
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende native Ganzzahl ohne Vorzeichen.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die entsprechende native Ganzzahl ohne Vorzeichen.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende native Ganzzahl ohne Vorzeichen.
Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in die entsprechende native Ganzzahl ohne Vorzeichen.
PopCount(UIntPtr)	Berechnet die Anzahl der Bits, die in einem Wert festgelegt sind.
RotateLeft(UIntPtr, Int32)	Rotiert einen Wert, der um einen bestimmten Betrag verlassen wird.
RotateRight(UIntPtr, Int32)	Rotiert einen Wert nach rechts um einen bestimmten Betrag.
Sign(UIntPtr)	Berechnet das Vorzeichen eines Werts.
Subtract(UIntPtr, Int32)	Subtrahiert einen Offset von einer ganzen Zahl ohne Vorzeichen.
ToPointer()	Konvertiert den Wert dieser Instanz in einen Zeiger auf einen nicht angegebenen Typ.
ToString()	Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.
ToString(IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
ToString(String)	Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.
ToString(String, IFormatProvider)	Formatiert den Wert der aktuellen Instanz mit dem angegebenen Format.
ToUInt32()	Konvertiert den Wert dieser Instanz in eine 32-Bit-Ganzzahl ohne Vorzeichen.
ToUInt64()	Konvertiert den Wert dieser Instanz in eine ganze 64-Bit-Zahl ohne Vorzeichen.
TrailingZeroCount(UIntPtr)	Berechnet die Anzahl der nachfolgenden Nullen in einem Wert.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert des aktuellen instance als UTF-8 in die angegebene Bytesspanne zu formatieren.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert des aktuellen instance in die angegebene Zeichenspanne zu formatieren.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, UIntPtr)	Versucht, eine Spanne von UTF-8-Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, UIntPtr)	Versucht, eine Spanne von UTF-8-Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Byte>, UIntPtr)	Versucht, eine UTF-8-Zeichenspanne, die die Zeichenfolgendarstellung einer Zahl enthält, in ihre Entsprechung ohne Vorzeichen zu konvertieren.
TryParse(ReadOnlySpan<Char>, IFormatProvider, UIntPtr)	Versucht, eine Zeichenfolge in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, UIntPtr)	Konvertiert die schreibgeschützte Spanne der Zeichendarstellung einer Zahl in einem angegebenen Format und kulturspezifischen Format in die native Ganzzahl-Entsprechung ohne Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.
TryParse(ReadOnlySpan<Char>, UIntPtr)	Konvertiert die schreibgeschützte Spanne der Zeichendarstellung einer Zahl in die native Entsprechung ohne Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.
TryParse(String, IFormatProvider, UIntPtr)	Versucht, eine Zeichenfolge in einen Wert zu analysieren.
TryParse(String, NumberStyles, IFormatProvider, UIntPtr)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in die entsprechende native Ganzzahl ohne Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.
TryParse(String, UIntPtr)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende native Ganzzahl ohne Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.

Operatoren

Addition(UIntPtr, Int32)	Fügt einer ganzzahligen Zahl ohne Vorzeichen einen Offset hinzu.
Equality(UIntPtr, UIntPtr)	Bestimmt, ob zwei angegebene Instanzen von UIntPtr gleich sind.
Explicit(UInt32 to UIntPtr)	Konvertiert den Wert einer 32-Bit-Ganzzahl ohne Vorzeichen in einen UIntPtr.
Explicit(UInt64 to UIntPtr)	Konvertiert den Wert einer ganzen 64-Bit-Zahl ohne Vorzeichen in einen UIntPtr.
Explicit(UIntPtr to UInt32)	Konvertiert den Wert des angegebenen UIntPtr in eine 32-Bit-Ganzzahl ohne Vorzeichen.
Explicit(UIntPtr to UInt64)	Konvertiert den Wert des angegebenen UIntPtr in eine ganze 64-Bit-Zahl ohne Vorzeichen.
Explicit(UIntPtr to Void*)	Konvertiert den Wert des angegebenen UIntPtr in einen Zeiger auf einen nicht angegebenen Typ. Diese API ist nicht CLS-kompatibel.
Explicit(Void* to UIntPtr)	Konvertiert den angegebenen Zeiger auf einen nicht angegebenen Typ in einen UIntPtr. Diese API ist nicht CLS-kompatibel.
Inequality(UIntPtr, UIntPtr)	Bestimmt, ob zwei angegebene Instanzen von UIntPtr nicht gleich sind.
Subtraction(UIntPtr, Int32)	Subtrahiert einen Offset von einer ganzen Zahl ohne Vorzeichen.

Explizite Schnittstellenimplementierungen

IAdditionOperators<UIntPtr,UIntPtr,UIntPtr>.Addition(UIntPtr, UIntPtr)	Fügt zwei Werte zusammen, um ihre Summe zu berechnen.
IAdditionOperators<UIntPtr,UIntPtr,UIntPtr>.CheckedAddition(UIntPtr, UIntPtr)	Fügt zwei Werte zusammen, um ihre Summe zu berechnen.
IAdditiveIdentity<UIntPtr,UIntPtr>.AdditiveIdentity	Ruft die additive Identität des aktuellen Typs ab.
IBinaryInteger<UIntPtr>.GetByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteLittleEndian(Span<Byte>, Int32)geschrieben werden.
IBinaryInteger<UIntPtr>.GetShortestBitLength()	Ruft die Länge der Komplementdarstellung des aktuellen Werts in Bits ab.
IBinaryInteger<UIntPtr>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, UIntPtr)	Stellt eine ganze Zahl ohne Vorzeichen dar, bei der die Bitbreite mit einem Zeiger übereinstimmt.
IBinaryInteger<UIntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, UIntPtr)	Stellt eine ganze Zahl ohne Vorzeichen dar, bei der die Bitbreite mit einem Zeiger übereinstimmt.
IBinaryInteger<UIntPtr>.TryWriteBigEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Big-End-Format in eine bestimmte Spanne zu schreiben.
IBinaryInteger<UIntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Little-Endian-Format in eine bestimmte Spanne zu schreiben.
IBinaryNumber<UIntPtr>.AllBitsSet	Ruft eine instance des Binärtyps ab, in dem alle Bits festgelegt sind.
IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.BitwiseAnd(UIntPtr, UIntPtr)	Berechnet den bitweisen und von zwei Werten.
IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.BitwiseOr(UIntPtr, UIntPtr)	Berechnet den bitweisen oder von zwei Werten.
IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.ExclusiveOr(UIntPtr, UIntPtr)	Berechnet den exklusiven oder von zwei Werten.
IBitwiseOperators<UIntPtr,UIntPtr,UIntPtr>.OnesComplement(UIntPtr)	Berechnet die Eins-Komplement-Darstellung eines bestimmten Werts.
IComparisonOperators<UIntPtr,UIntPtr,Boolean>.GreaterThan(UIntPtr, UIntPtr)	Vergleicht zwei Werte, um zu ermitteln, welcher größer ist.
IComparisonOperators<UIntPtr,UIntPtr,Boolean>.GreaterThanOrEqual(UIntPtr, UIntPtr)	Vergleicht zwei Werte, um zu bestimmen, welche größer oder gleich sind.
IComparisonOperators<UIntPtr,UIntPtr,Boolean>.LessThan(UIntPtr, UIntPtr)	Vergleicht zwei Werte, um zu ermitteln, welcher kleiner ist.
IComparisonOperators<UIntPtr,UIntPtr,Boolean>.LessThanOrEqual(UIntPtr, UIntPtr)	Vergleicht zwei Werte, um zu bestimmen, welche kleiner oder gleich sind.
IDecrementOperators<UIntPtr>.CheckedDecrement(UIntPtr)	Dekrementiert einen Wert.
IDecrementOperators<UIntPtr>.Decrement(UIntPtr)	Dekrementiert einen Wert.
IDivisionOperators<UIntPtr,UIntPtr,UIntPtr>.Division(UIntPtr, UIntPtr)	Dividiert einen Wert durch einen anderen, um den Quotienten zu berechnen.
IIncrementOperators<UIntPtr>.CheckedIncrement(UIntPtr)	Erhöht einen Wert.
IIncrementOperators<UIntPtr>.Increment(UIntPtr)	Erhöht einen Wert.
IMinMaxValue<UIntPtr>.MaxValue	Ruft den Maximalwert des aktuellen Typs ab.
IMinMaxValue<UIntPtr>.MinValue	Ruft den Mindestwert des aktuellen Typs ab.
IModulusOperators<UIntPtr,UIntPtr,UIntPtr>.Modulus(UIntPtr, UIntPtr)	Teilt zwei Werte zusammen, um deren Modul oder Rest zu berechnen.
IMultiplicativeIdentity<UIntPtr,UIntPtr>.MultiplicativeIdentity	Ruft die multiplikative Identität des aktuellen Typs ab.
IMultiplyOperators<UIntPtr,UIntPtr,UIntPtr>.CheckedMultiply(UIntPtr, UIntPtr)	Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.
IMultiplyOperators<UIntPtr,UIntPtr,UIntPtr>.Multiply(UIntPtr, UIntPtr)	Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.
INumber<UIntPtr>.CopySign(UIntPtr, UIntPtr)	Kopiert das Zeichen eines Werts in das Zeichen eines anderen Werts.
INumber<UIntPtr>.MaxNumber(UIntPtr, UIntPtr)	Vergleicht zwei Werte mit der Berechnung, die größer ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumber<UIntPtr>.MinNumber(UIntPtr, UIntPtr)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<UIntPtr>.Abs(UIntPtr)	Berechnet das Absolute eines Werts.
INumberBase<UIntPtr>.IsCanonical(UIntPtr)	Bestimmt, ob sich ein Wert in seiner kanonischen Darstellung befindet.
INumberBase<UIntPtr>.IsComplexNumber(UIntPtr)	Bestimmt, ob ein Wert eine komplexe Zahl darstellt.
INumberBase<UIntPtr>.IsFinite(UIntPtr)	Bestimmt, ob ein Wert endlich ist.
INumberBase<UIntPtr>.IsImaginaryNumber(UIntPtr)	Bestimmt, ob ein Wert eine reine imaginäre Zahl darstellt.
INumberBase<UIntPtr>.IsInfinity(UIntPtr)	Bestimmt, ob ein Wert unendlich ist.
INumberBase<UIntPtr>.IsInteger(UIntPtr)	Bestimmt, ob ein Wert eine integrale Zahl darstellt.
INumberBase<UIntPtr>.IsNaN(UIntPtr)	Bestimmt, ob ein Wert NaN ist.
INumberBase<UIntPtr>.IsNegative(UIntPtr)	Bestimmt, ob ein Wert negativ ist.
INumberBase<UIntPtr>.IsNegativeInfinity(UIntPtr)	Bestimmt, ob ein Wert negativ unendlich ist.
INumberBase<UIntPtr>.IsNormal(UIntPtr)	Bestimmt, ob ein Wert normal ist.
INumberBase<UIntPtr>.IsPositive(UIntPtr)	Bestimmt, ob ein Wert positiv ist.
INumberBase<UIntPtr>.IsPositiveInfinity(UIntPtr)	Bestimmt, ob ein Wert positiv unendlich ist.
INumberBase<UIntPtr>.IsRealNumber(UIntPtr)	Bestimmt, ob ein Wert eine reelle Zahl darstellt.
INumberBase<UIntPtr>.IsSubnormal(UIntPtr)	Bestimmt, ob ein Wert subnormal ist.
INumberBase<UIntPtr>.IsZero(UIntPtr)	Bestimmt, ob ein Wert 0 ist.
INumberBase<UIntPtr>.MaxMagnitude(UIntPtr, UIntPtr)	Vergleicht zwei Werte mit der Berechnung, die größer ist.
INumberBase<UIntPtr>.MaxMagnitudeNumber(UIntPtr, UIntPtr)	Vergleicht zwei Werte mit der Berechnung, die die größere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<UIntPtr>.MinMagnitude(UIntPtr, UIntPtr)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
INumberBase<UIntPtr>.MinMagnitudeNumber(UIntPtr, UIntPtr)	Vergleicht zwei Werte mit der Berechnung, die die geringere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<UIntPtr>.One	Ruft den Wert 1 für den Typ ab.
INumberBase<UIntPtr>.Radix	Ruft die Basis für den Typ ab.
INumberBase<UIntPtr>.TryConvertFromChecked<TOther>(TOther, UIntPtr)	Stellt eine ganze Zahl ohne Vorzeichen dar, bei der die Bitbreite mit einem Zeiger übereinstimmt.
INumberBase<UIntPtr>.TryConvertFromSaturating<TOther>(TOther, UIntPtr)	Stellt eine ganze Zahl ohne Vorzeichen dar, bei der die Bitbreite mit einem Zeiger übereinstimmt.
INumberBase<UIntPtr>.TryConvertFromTruncating<TOther>(TOther, UIntPtr)	Stellt eine ganze Zahl ohne Vorzeichen dar, bei der die Bitbreite mit einem Zeiger übereinstimmt.
INumberBase<UIntPtr>.TryConvertToChecked<TOther>(UIntPtr, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<UIntPtr>.TryConvertToSaturating<TOther>(UIntPtr, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren und dabei alle Werte zu überlasten, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<UIntPtr>.TryConvertToTruncating<TOther>(UIntPtr, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wobei alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<UIntPtr>.Zero	Ruft den Wert 0 für den Typ ab.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Füllt ein SerializationInfo-Objekt mit den für das Serialisieren des aktuellen UIntPtr-Objekts erforderlichen Daten.
IShiftOperators<UIntPtr,Int32,UIntPtr>.LeftShift(UIntPtr, Int32)	Verschiebt einen Wert, der von einem bestimmten Betrag übrig bleibt.
IShiftOperators<UIntPtr,Int32,UIntPtr>.RightShift(UIntPtr, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.
IShiftOperators<UIntPtr,Int32,UIntPtr>.UnsignedRightShift(UIntPtr, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.
ISubtractionOperators<UIntPtr,UIntPtr,UIntPtr>.CheckedSubtraction(UIntPtr, UIntPtr)	Subtrahiert zwei Werte, um deren Differenz zu berechnen.
ISubtractionOperators<UIntPtr,UIntPtr,UIntPtr>.Subtraction(UIntPtr, UIntPtr)	Subtrahiert zwei Werte, um deren Differenz zu berechnen.
IUnaryNegationOperators<UIntPtr,UIntPtr>.CheckedUnaryNegation(UIntPtr)	Berechnet die überprüfte unäre Negation eines Werts.
IUnaryNegationOperators<UIntPtr,UIntPtr>.UnaryNegation(UIntPtr)	Berechnet die unäre Negation eines Werts.
IUnaryPlusOperators<UIntPtr,UIntPtr>.UnaryPlus(UIntPtr)	Berechnet das unäre Plus eines Werts.

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen

• IntPtr