IntPtr Struktura

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Źródło:

IntPtr.cs

Reprezentuje podpisaną liczbę całkowitą, w której szerokość bitów jest taka sama jak wskaźnik.

public value class IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<IntPtr>, IUtf8SpanParsable<IntPtr>, System::Numerics::IAdditionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IAdditiveIdentity<IntPtr, IntPtr>, System::Numerics::IBinaryInteger<IntPtr>, System::Numerics::IBinaryNumber<IntPtr>, System::Numerics::IBitwiseOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IComparisonOperators<IntPtr, IntPtr, bool>, System::Numerics::IDecrementOperators<IntPtr>, System::Numerics::IDivisionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IEqualityOperators<IntPtr, IntPtr, bool>, System::Numerics::IIncrementOperators<IntPtr>, System::Numerics::IMinMaxValue<IntPtr>, System::Numerics::IModulusOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IMultiplicativeIdentity<IntPtr, IntPtr>, System::Numerics::IMultiplyOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::INumber<IntPtr>, System::Numerics::INumberBase<IntPtr>, System::Numerics::IShiftOperators<IntPtr, int, IntPtr>, System::Numerics::ISignedNumber<IntPtr>, System::Numerics::ISubtractionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IUnaryNegationOperators<IntPtr, IntPtr>, System::Numerics::IUnaryPlusOperators<IntPtr, IntPtr>, System::Runtime::Serialization::ISerializable

public readonly struct IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<IntPtr>, IUtf8SpanParsable<IntPtr>, System.Numerics.IAdditionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IAdditiveIdentity<IntPtr,IntPtr>, System.Numerics.IBinaryInteger<IntPtr>, System.Numerics.IBinaryNumber<IntPtr>, System.Numerics.IBitwiseOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IComparisonOperators<IntPtr,IntPtr,bool>, System.Numerics.IDecrementOperators<IntPtr>, System.Numerics.IDivisionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IEqualityOperators<IntPtr,IntPtr,bool>, System.Numerics.IIncrementOperators<IntPtr>, System.Numerics.IMinMaxValue<IntPtr>, System.Numerics.IModulusOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IMultiplicativeIdentity<IntPtr,IntPtr>, System.Numerics.IMultiplyOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.INumber<IntPtr>, System.Numerics.INumberBase<IntPtr>, System.Numerics.IShiftOperators<IntPtr,int,IntPtr>, System.Numerics.ISignedNumber<IntPtr>, System.Numerics.ISubtractionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IUnaryNegationOperators<IntPtr,IntPtr>, System.Numerics.IUnaryPlusOperators<IntPtr,IntPtr>, System.Runtime.Serialization.ISerializable

type nativeint = struct
    interface IFormattable
    interface IParsable<nativeint>
    interface ISpanFormattable
    interface ISpanParsable<nativeint>
    interface IAdditionOperators<nativeint, nativeint, nativeint>
    interface IAdditiveIdentity<nativeint, nativeint>
    interface IBinaryInteger<nativeint>
    interface IBinaryNumber<nativeint>
    interface IBitwiseOperators<nativeint, nativeint, nativeint>
    interface IComparisonOperators<nativeint, nativeint, bool>
    interface IEqualityOperators<nativeint, nativeint, bool>
    interface IDecrementOperators<nativeint>
    interface IDivisionOperators<nativeint, nativeint, nativeint>
    interface IIncrementOperators<nativeint>
    interface IModulusOperators<nativeint, nativeint, nativeint>
    interface IMultiplicativeIdentity<nativeint, nativeint>
    interface IMultiplyOperators<nativeint, nativeint, nativeint>
    interface INumber<nativeint>
    interface INumberBase<nativeint>
    interface ISubtractionOperators<nativeint, nativeint, nativeint>
    interface IUnaryNegationOperators<nativeint, nativeint>
    interface IUnaryPlusOperators<nativeint, nativeint>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<nativeint>
    interface IShiftOperators<nativeint, int, nativeint>
    interface IMinMaxValue<nativeint>
    interface ISignedNumber<nativeint>
    interface ISerializable

Public Structure IntPtr
Implements IAdditionOperators(Of IntPtr, IntPtr, IntPtr), IAdditiveIdentity(Of IntPtr, IntPtr), IBinaryInteger(Of IntPtr), IBinaryNumber(Of IntPtr), IBitwiseOperators(Of IntPtr, IntPtr, IntPtr), IComparable(Of IntPtr), IComparisonOperators(Of IntPtr, IntPtr, Boolean), IDecrementOperators(Of IntPtr), IDivisionOperators(Of IntPtr, IntPtr, IntPtr), IEqualityOperators(Of IntPtr, IntPtr, Boolean), IEquatable(Of IntPtr), IIncrementOperators(Of IntPtr), IMinMaxValue(Of IntPtr), IModulusOperators(Of IntPtr, IntPtr, IntPtr), IMultiplicativeIdentity(Of IntPtr, IntPtr), IMultiplyOperators(Of IntPtr, IntPtr, IntPtr), INumber(Of IntPtr), INumberBase(Of IntPtr), IParsable(Of IntPtr), ISerializable, IShiftOperators(Of IntPtr, Integer, IntPtr), ISignedNumber(Of IntPtr), ISpanParsable(Of IntPtr), ISubtractionOperators(Of IntPtr, IntPtr, IntPtr), IUnaryNegationOperators(Of IntPtr, IntPtr), IUnaryPlusOperators(Of IntPtr, IntPtr), IUtf8SpanParsable(Of IntPtr)

Dziedziczenie

Object

ValueType

IntPtr

Implementuje

IComparable IComparable<IntPtr> IEquatable<IntPtr> IFormattable ISerializable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<IntPtr> IParsable<TSelf> ISpanParsable<IntPtr> ISpanParsable<TSelf> IAdditionOperators<IntPtr,IntPtr,IntPtr> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<IntPtr,IntPtr> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<IntPtr> IBinaryNumber<IntPtr> IBinaryNumber<TSelf> IBitwiseOperators<IntPtr,IntPtr,IntPtr> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<IntPtr,IntPtr,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<IntPtr> IDecrementOperators<TSelf> IDivisionOperators<IntPtr,IntPtr,IntPtr> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<IntPtr,IntPtr,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IIncrementOperators<IntPtr> IIncrementOperators<TSelf> IMinMaxValue<IntPtr> IModulusOperators<IntPtr,IntPtr,IntPtr> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<IntPtr,IntPtr> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<IntPtr,IntPtr,IntPtr> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<IntPtr> INumber<TSelf> INumberBase<IntPtr> INumberBase<TSelf> IShiftOperators<IntPtr,Int32,IntPtr> IShiftOperators<TSelf,Int32,TSelf> ISignedNumber<IntPtr> ISubtractionOperators<IntPtr,IntPtr,IntPtr> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<IntPtr,IntPtr> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<IntPtr,IntPtr> IUnaryPlusOperators<TSelf,TSelf> IUtf8SpanFormattable IUtf8SpanParsable<IntPtr> IUtf8SpanParsable<TSelf>

Przykłady

W poniższym przykładzie użyto zarządzanych wskaźników w celu odwrócenia znaków w tablicy. Po zainicjowaniu obiektu String i jego długości wykonuje następujące czynności:

1. Wywołuje metodę Marshal.StringToHGlobalAnsi, aby skopiować ciąg Unicode do niezarządzanej pamięci jako znak ANSI (jeden bajt). Metoda zwraca obiekt IntPtr wskazujący początek niezarządzanego ciągu. Przykład języka Visual Basic używa tego wskaźnika bezpośrednio; w przykładach języków C++, F# i C# jest rzutowany do wskaźnika do bajtu.

2. Wywołuje metodę Marshal.AllocHGlobal, aby przydzielić taką samą liczbę bajtów, jak zajmuje niezarządzany ciąg. Metoda zwraca obiekt IntPtr wskazujący początek niezarządzanego bloku pamięci. Przykład języka Visual Basic używa tego wskaźnika bezpośrednio; w przykładach języków C++, F# i C# jest rzutowany do wskaźnika do bajtu.

3. Przykład języka Visual Basic definiuje zmienną o nazwie offset, która jest równa długości ciągu ANSI. Służy do określania przesunięcia do niezarządzanej pamięci, do której jest kopiowany następny znak w ciągu ANSI. Ponieważ jego wartość początkowa to długość ciągu, operacja kopiowania skopiuje znak od początku ciągu na koniec bloku pamięci.

   Przykłady języków C#, F# i C++ wywołają metodę ToPointer, aby uzyskać wskaźnik niezarządzany na adres początkowy ciągu i niezarządzany blok pamięci, a następnie dodają jedną mniejszą niż długość ciągu do adresu początkowego ciągu ANSI. Ponieważ niezarządzany wskaźnik ciągu wskazuje teraz na koniec ciągu, operacja kopiowania skopiuje znak z końca ciągu na początek bloku pamięci.

4. Używa pętli do kopiowania każdego znaku z ciągu do niezarządzanego bloku pamięci.

   Przykład języka Visual Basic wywołuje metodę Marshal.ReadByte(IntPtr, Int32) w celu odczytania bajtu (lub znaku jednobajtowego) z określonego przesunięcia z zarządzanego wskaźnika do ciągu ANSI. Przesunięcie jest zwiększane z każdą iterację pętli. Następnie wywołuje metodę Marshal.WriteByte(IntPtr, Int32, Byte), aby zapisać bajt na adres pamięci zdefiniowany przez adres początkowy niezarządzanego bloku pamięci oraz offset. Następnie dekrementuje offset.

   Przykłady języków C#, F# i C++ wykonują operację kopiowania, a następnie dekrementuj wskaźnik do adresu następnej lokalizacji w niezarządzanym ciągu ANSI i zwiększa wskaźnik do następnego adresu w niezarządzanym bloku.

5. Wszystkie przykłady wywołają Marshal.PtrToStringAnsi, aby przekonwertować niezarządzany blok pamięci zawierający skopiowany ciąg ANSI do zarządzanego obiektu String Unicode.

6. Po wyświetleniu oryginalnych i odwróconych ciągów wszystkie przykłady wywołają metodę FreeHGlobal, aby zwolnić pamięć przydzieloną dla niezarządzanego ciągu ANSI i niezarządzanego bloku pamięci.

using namespace System;
using namespace System::Runtime::InteropServices;

class NotTooSafeStringReverse
{
public:
    static void Main()
    {
        String^ stringA = "I seem to be turned around!";
        int copylen = stringA->Length;

        // Allocate HGlobal memory for source and destination strings
        IntPtr sptr = Marshal::StringToHGlobalAnsi(stringA);
        IntPtr dptr = Marshal::AllocHGlobal(copylen + 1);

        char *src = (char *)sptr.ToPointer();
        char *dst = (char *)dptr.ToPointer();

        if (copylen > 0)
        {
            // set the source pointer to the end of the string
            // to do a reverse copy.
            src += copylen - 1;

            while (copylen-- > 0)
            {
                *dst++ = *src--;
            }
            *dst = 0;
        }
        String^ stringB = Marshal::PtrToStringAnsi(dptr);

        Console::WriteLine("Original:\n{0}\n", stringA);
        Console::WriteLine("Reversed:\n{0}", stringB);

        // Free HGlobal memory
        Marshal::FreeHGlobal(dptr);
        Marshal::FreeHGlobal(sptr);
    }
};

int main()
{
    NotTooSafeStringReverse::Main();
}

// The progam has the following output:
//
// Original:
// I seem to be turned around!
//
// Reversed:
// !dnuora denrut eb ot mees I

using System;
using System.Runtime.InteropServices;

class NotTooSafeStringReverse
{
    static public void Main()
    {
        string stringA = "I seem to be turned around!";
        int copylen = stringA.Length;

        // Allocate HGlobal memory for source and destination strings
        IntPtr sptr = Marshal.StringToHGlobalAnsi(stringA);
        IntPtr dptr = Marshal.AllocHGlobal(copylen + 1);

        // The unsafe section where byte pointers are used.
        unsafe
        {
            byte *src = (byte *)sptr.ToPointer();
            byte *dst = (byte *)dptr.ToPointer();

            if (copylen > 0)
            {
                // set the source pointer to the end of the string
                // to do a reverse copy.
                src += copylen - 1;

                while (copylen-- > 0)
                {
                    *dst++ = *src--;
                }
                *dst = 0;
            }
        }
        string stringB = Marshal.PtrToStringAnsi(dptr);

        Console.WriteLine("Original:\n{0}\n", stringA);
        Console.WriteLine("Reversed:\n{0}", stringB);

        // Free HGlobal memory
        Marshal.FreeHGlobal(dptr);
        Marshal.FreeHGlobal(sptr);
    }
}

// The progam has the following output:
//
// Original:
// I seem to be turned around!
//
// Reversed:
// !dnuora denrut eb ot mees I

#nowarn "9"
open System.Runtime.InteropServices
open FSharp.NativeInterop

[<EntryPoint>]
let main _ = 
    let stringA = "I seem to be turned around!"
    let mutable copylen = stringA.Length

    // Allocate HGlobal memory for source and destination strings
    let sptr = Marshal.StringToHGlobalAnsi stringA
    let dptr = Marshal.AllocHGlobal(copylen + 1)

    let mutable src: byte nativeptr = sptr.ToPointer() |> NativePtr.ofVoidPtr
    let mutable dst: byte nativeptr = dptr.ToPointer() |> NativePtr.ofVoidPtr

    if copylen > 0 then
        // set the source pointer to the end of the string
        // to do a reverse copy.
        src <- 
            NativePtr.toNativeInt src + nativeint (copylen - 1) 
            |> NativePtr.ofNativeInt

        while copylen > 0 do
            copylen <- copylen - 1
            NativePtr.read src |> NativePtr.write dst
            dst <- NativePtr.toNativeInt dst + 1n |> NativePtr.ofNativeInt
            src <- NativePtr.toNativeInt src - 1n |> NativePtr.ofNativeInt
        NativePtr.write dst 0uy

    let stringB = Marshal.PtrToStringAnsi dptr

    printfn $"Original:\n{stringA}\n"
    printfn $"Reversed:\n{stringB}"

    // Free HGlobal memory
    Marshal.FreeHGlobal dptr
    Marshal.FreeHGlobal sptr
    0

// The progam has the following output:
//
// Original:
// I seem to be turned around!
//
// Reversed:
// !dnuora denrut eb ot mees I

Imports System.Runtime.InteropServices

Public Module Example
    Public Sub Main()
        Dim stringA As String = "I seem to be turned around!"
        Dim copylen As Integer = stringA.Length

        ' Allocate HGlobal memory for source and destination strings
        Dim sptr As IntPtr = Marshal.StringToHGlobalAnsi(stringA)
        Dim dptr As IntPtr = Marshal.AllocHGlobal(copylen)
        Dim offset As Integer = copylen - 1

         For ctr As Integer = 0 To copylen - 1
            Dim b As Byte = Marshal.ReadByte(sptr, ctr)
            Marshal.WriteByte(dptr, offset, b)
            offset -= 1
         Next

        Dim stringB As String = Marshal.PtrToStringAnsi(dptr)

        Console.WriteLine("Original:{1}{0}{1}", stringA, vbCrLf)
        Console.WriteLine("Reversed:{1}{0}{1}", stringB, vbCrLf)

        ' Free HGlobal memory
        Marshal.FreeHGlobal(dptr)
        Marshal.FreeHGlobal(sptr)
    End Sub
End Module
' The example displays the following output:
'       Original:
'       I seem to be turned around!
'
'       Reversed:
'       !dnuora denrut eb ot mees I

Uwagi

Typ IntPtr jest przeznaczony do liczby całkowitej, której rozmiar jest taki sam jak wskaźnik. Oznacza to, że wystąpienie tego typu ma być 32-bitowe w procesie 32-bitowym i 64 bitów w procesie 64-bitowym.

Typ IntPtr może być używany przez języki, które obsługują wskaźniki i jako typowe sposoby odwoływania się do danych między językami, które nie obsługują wskaźników.

IntPtr obiektów można również użyć do przechowywania dojść. Na przykład wystąpienia IntPtr są szeroko używane w klasie System.IO.FileStream do przechowywania dojść do plików.

Nuta

Używanie IntPtr jako wskaźnika lub uchwytu jest podatne na błędy i niebezpieczne. Jest to po prostu typ liczby całkowitej, który może być używany jako format wymiany wskaźników i dojść z powodu tego samego rozmiaru. Poza określonymi wymaganiami dotyczącymi wymiany, takimi jak przekazywanie danych do języka, który nie obsługuje wskaźników, należy użyć poprawnie wpisanego wskaźnika do reprezentowania wskaźników i SafeHandle służyć do reprezentowania dojść.

Ten typ implementuje ISerializable. W wersjach .NET 5 i nowszych ten typ implementuje również interfejsy IFormattable. W wersjach .NET 7 i nowszych ten typ implementuje również interfejsy IBinaryInteger<TSelf>, IMinMaxValue<TSelf>i ISignedNumber<TSelf>.

W języku C# począwszy od wersji 9.0 można użyć wbudowanego typu nint do zdefiniowania liczb całkowitych o rozmiarze natywnym. Ten typ jest reprezentowany przez typ IntPtr wewnętrznie i zapewnia operacje i konwersje, które są odpowiednie dla typów całkowitych. Aby uzyskać więcej informacji, zobacz nint i nuint types.

W języku C# począwszy od wersji 11 i w przypadku określania wartości docelowej środowiska uruchomieniowego platformy .NET 7 lub nowszego nint jest aliasem dla IntPtr w taki sam sposób, jak int jest aliasem Int32.

Konstruktory

IntPtr(Int32)	Inicjuje nowe wystąpienie IntPtr przy użyciu określonej 32-bitowej liczby całkowitej ze znakiem.
IntPtr(Int64)	Inicjuje nowe wystąpienie IntPtr przy użyciu określonej 64-bitowej liczby całkowitej ze znakiem.
IntPtr(Void*)	Inicjuje nowe wystąpienie IntPtr przy użyciu określonego wskaźnika do nieokreślonego typu.

Pola

Zero	Pole tylko do odczytu, które reprezentuje podpisaną liczbę całkowitą, która została zainicjowana na zero.

Właściwości

MaxValue	Pobiera największą możliwą wartość IntPtr.
MinValue	Pobiera najmniejszą możliwą wartość IntPtr.
Size	Pobiera rozmiar tego wystąpienia.

Metody

Abs(IntPtr)	Oblicza wartość bezwzględną.
Add(IntPtr, Int32)	Dodaje przesunięcie do podpisanej liczby całkowitej.
Clamp(IntPtr, IntPtr, IntPtr)	Zaciska wartość do wartości minimalnej i maksymalnej.
CompareTo(IntPtr)	Porównuje bieżące wystąpienie z innym obiektem tego samego typu i zwraca liczbę całkowitą wskazującą, czy bieżące wystąpienie poprzedza, następuje, czy występuje w tej samej pozycji w kolejności sortowania co drugi obiekt.
CompareTo(Object)	Porównuje bieżące wystąpienie z innym obiektem tego samego typu i zwraca liczbę całkowitą wskazującą, czy bieżące wystąpienie poprzedza, następuje, czy występuje w tej samej pozycji w kolejności sortowania co drugi obiekt.
CopySign(IntPtr, IntPtr)	Kopiuje znak wartości do znaku innej wartości.
CreateChecked<TOther>(TOther)	Tworzy wystąpienie bieżącego typu na podstawie wartości, zgłaszając wyjątek przepełnienia dla wszystkich wartości, które mieszczą się poza dopuszczalnym zakresem bieżącego typu.
CreateSaturating<TOther>(TOther)	Tworzy wystąpienie bieżącego typu na podstawie wartości, usytując wszystkie wartości, które wykraczają poza reprezentowany zakres bieżącego typu.
CreateTruncating<TOther>(TOther)	Tworzy wystąpienie bieżącego typu na podstawie wartości, obcinając wszystkie wartości, które wykraczają poza reprezentowany zakres bieżącego typu.
DivRem(IntPtr, IntPtr)	Oblicza iloraz i pozostałą część dwóch wartości.
Equals(IntPtr)	Wskazuje, czy bieżący obiekt jest równy innemu obiektowi tego samego typu.
Equals(Object)	Zwraca wartość wskazującą, czy to wystąpienie jest równe określonemu obiektowi.
GetHashCode()	Zwraca kod skrótu dla tego wystąpienia.
IsEvenInteger(IntPtr)	Określa, czy wartość reprezentuje liczbę całkowitą parzystą.
IsNegative(IntPtr)	Określa, czy wartość jest ujemna.
IsOddInteger(IntPtr)	Określa, czy wartość reprezentuje nieparzystną liczbę całkowitą.
IsPositive(IntPtr)	Określa, czy wartość jest dodatnia.
IsPow2(IntPtr)	Określa, czy wartość jest potęgą dwóch.
LeadingZeroCount(IntPtr)	Oblicza liczbę zer wiodących w wartości.
Log2(IntPtr)	Oblicza dziennik2 wartości.
Max(IntPtr, IntPtr)	Porównuje dwie wartości z obliczeniami, które są większe.
MaxMagnitude(IntPtr, IntPtr)	Porównuje dwie wartości z obliczeniami, które są większe.
Min(IntPtr, IntPtr)	Porównuje dwie wartości z obliczeniami, które są mniejsze.
MinMagnitude(IntPtr, IntPtr)	Porównuje dwie wartości z obliczeniami, które są mniejsze.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analizuje zakres znaków UTF-8 w wartość.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analizuje zakres znaków UTF-8 w wartość.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analizuje zakres znaków w wartości.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konwertuje zakres znaków tylko do odczytu reprezentujący liczbę w określonym stylu i formacie specyficznym dla kultury na jego podpisaną natywną liczbę całkowitą.
Parse(String)	Konwertuje reprezentację ciągu liczby na podpisaną natywną liczbę całkowitą równoważną.
Parse(String, IFormatProvider)	Konwertuje reprezentację ciągu liczby w określonym formacie specyficznym dla kultury na jego podpisaną natywną liczbę całkowitą równoważną.
Parse(String, NumberStyles)	Konwertuje reprezentację ciągu liczby w określonym stylu na jej podpisaną natywną liczbę całkowitą równoważną.
Parse(String, NumberStyles, IFormatProvider)	Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na jego podpisaną natywną liczbę całkowitą równoważną.
PopCount(IntPtr)	Oblicza liczbę bitów ustawionych w wartości.
RotateLeft(IntPtr, Int32)	Obraca wartość pozostawioną przez daną kwotę.
RotateRight(IntPtr, Int32)	Obraca wartość w prawo o daną kwotę.
Sign(IntPtr)	Oblicza znak wartości.
Subtract(IntPtr, Int32)	Odejmuje przesunięcie ze podpisanej liczby całkowitej.
ToInt32()	Konwertuje wartość tego wystąpienia na 32-bitową liczbę całkowitą ze znakiem.
ToInt64()	Konwertuje wartość tego wystąpienia na 64-bitową liczbę całkowitą ze znakiem.
ToPointer()	Konwertuje wartość tego wystąpienia na wskaźnik do nieokreślonego typu.
ToString()	Konwertuje wartość liczbową bieżącego obiektu IntPtr na równoważną reprezentację ciągu.
ToString(IFormatProvider)	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację ciągu przy użyciu określonego formatu i informacji o formacie specyficznym dla kultury.
ToString(String)	Konwertuje wartość liczbową bieżącego obiektu IntPtr na równoważną reprezentację ciągu.
ToString(String, IFormatProvider)	Formatuje wartość bieżącego wystąpienia przy użyciu określonego formatu.
TrailingZeroCount(IntPtr)	Oblicza liczbę końcowych zer w wartości.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Próbuje sformatować wartość bieżącego wystąpienia jako UTF-8 w podanym zakresie bajtów.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Próbuje sformatować wartość bieżącego wystąpienia w podanym zakresie znaków.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, IntPtr)	Próbuje przeanalizować zakres znaków UTF-8 w wartość.
TryParse(ReadOnlySpan<Byte>, IntPtr)	Próbuje przekonwertować zakres znaków UTF-8 zawierający reprezentację ciągu liczby na jego podpisaną liczbę całkowitą równoważną.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, IntPtr)	Próbuje przeanalizować zakres znaków UTF-8 w wartość.
TryParse(ReadOnlySpan<Char>, IFormatProvider, IntPtr)	Próbuje przeanalizować ciąg w wartości.
TryParse(ReadOnlySpan<Char>, IntPtr)	Konwertuje zakres znaków tylko do odczytu reprezentujący liczbę na jego podpisaną natywną liczbę całkowitą równoważną. Wartość zwracana wskazuje, czy konwersja zakończyła się pomyślnie.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, IntPtr)	Konwertuje zakres znaków tylko do odczytu reprezentujący liczbę w określonym stylu i formacie specyficznym dla kultury na jego podpisaną natywną liczbę całkowitą. Wartość zwracana wskazuje, czy konwersja zakończyła się pomyślnie.
TryParse(String, IFormatProvider, IntPtr)	Próbuje przeanalizować ciąg w wartości.
TryParse(String, IntPtr)	Konwertuje reprezentację ciągu liczby na podpisaną natywną liczbę całkowitą równoważną. Wartość zwracana wskazuje, czy konwersja zakończyła się pomyślnie.
TryParse(String, NumberStyles, IFormatProvider, IntPtr)	Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na jego podpisaną natywną liczbę całkowitą równoważną. Wartość zwracana wskazuje, czy konwersja zakończyła się pomyślnie.

Operatory

Addition(IntPtr, Int32)	Dodaje przesunięcie do podpisanej liczby całkowitej.
Equality(IntPtr, IntPtr)	Określa, czy dwa określone wystąpienia IntPtr są równe.
Explicit(Int32 to IntPtr)	Konwertuje wartość 32-bitowej liczby całkowitej ze znakiem na IntPtr.
Explicit(Int64 to IntPtr)	Konwertuje wartość 64-bitowej liczby całkowitej ze znakiem na IntPtr.
Explicit(IntPtr to Int32)	Konwertuje wartość określonej IntPtr na 32-bitową liczbę całkowitą ze znakiem.
Explicit(IntPtr to Int64)	Konwertuje wartość określonej IntPtr na 64-bitową liczbę całkowitą ze znakiem.
Explicit(IntPtr to Void*)	Konwertuje wartość określonego IntPtr na wskaźnik na nieokreślony typ. Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Explicit(Void* to IntPtr)	Konwertuje określony wskaźnik na nieokreślony typ na IntPtr. Ten interfejs API nie jest zgodny ze specyfikacją CLS.
Inequality(IntPtr, IntPtr)	Określa, czy dwa określone wystąpienia IntPtr nie są równe.
Subtraction(IntPtr, Int32)	Odejmuje przesunięcie ze podpisanej liczby całkowitej.

Jawne implementacje interfejsu

IAdditionOperators<IntPtr,IntPtr,IntPtr>.Addition(IntPtr, IntPtr)	Dodaje dwie wartości w celu obliczenia ich sumy.
IAdditionOperators<IntPtr,IntPtr,IntPtr>.CheckedAddition(IntPtr, IntPtr)	Dodaje dwie wartości w celu obliczenia ich sumy.
IAdditiveIdentity<IntPtr,IntPtr>.AdditiveIdentity	Pobiera tożsamość addytywnego bieżącego typu.
IBinaryInteger<IntPtr>.GetByteCount()	Pobiera liczbę bajtów, które zostaną zapisane w ramach TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<IntPtr>.GetShortestBitLength()	Pobiera długość w bitach najkrótszej reprezentacji wartości bieżącej.
IBinaryInteger<IntPtr>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	Reprezentuje podpisaną liczbę całkowitą, w której szerokość bitów jest taka sama jak wskaźnik.
IBinaryInteger<IntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	Reprezentuje podpisaną liczbę całkowitą, w której szerokość bitów jest taka sama jak wskaźnik.
IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<Byte>, Int32)	Próbuje zapisać bieżącą wartość w formacie big-endian do danego zakresu.
IBinaryInteger<IntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)	Próbuje zapisać bieżącą wartość w formacie little-endian do danego zakresu.
IBinaryNumber<IntPtr>.AllBitsSet	Pobiera wystąpienie typu binarnego, w którym są ustawione wszystkie bity.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseAnd(IntPtr, IntPtr)	Oblicza bitowe wartości i dwie wartości.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseOr(IntPtr, IntPtr)	Oblicza bitowe lub dwie wartości.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.ExclusiveOr(IntPtr, IntPtr)	Oblicza wyłącznie lub dwie wartości.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.OnesComplement(IntPtr)	Oblicza reprezentację danej wartości jako uzupełnienie.
IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThan(IntPtr, IntPtr)	Porównuje dwie wartości, aby określić, która wartość jest większa.
IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThanOrEqual(IntPtr, IntPtr)	Porównuje dwie wartości, aby określić, które wartości są większe lub równe.
IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThan(IntPtr, IntPtr)	Porównuje dwie wartości, aby określić, które wartości są mniejsze.
IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThanOrEqual(IntPtr, IntPtr)	Porównuje dwie wartości, aby określić, które wartości są mniejsze lub równe.
IDecrementOperators<IntPtr>.CheckedDecrement(IntPtr)	Dekrementuje wartość.
IDecrementOperators<IntPtr>.Decrement(IntPtr)	Dekrementuje wartość.
IDivisionOperators<IntPtr,IntPtr,IntPtr>.Division(IntPtr, IntPtr)	Dzieli jedną wartość przez inną, aby obliczyć ich iloraz.
IIncrementOperators<IntPtr>.CheckedIncrement(IntPtr)	Zwiększa wartość.
IIncrementOperators<IntPtr>.Increment(IntPtr)	Zwiększa wartość.
IMinMaxValue<IntPtr>.MaxValue	Pobiera maksymalną wartość bieżącego typu.
IMinMaxValue<IntPtr>.MinValue	Pobiera minimalną wartość bieżącego typu.
IModulusOperators<IntPtr,IntPtr,IntPtr>.Modulus(IntPtr, IntPtr)	Dzieli dwie wartości, aby obliczyć ich modulo lub resztę.
IMultiplicativeIdentity<IntPtr,IntPtr>.MultiplicativeIdentity	Pobiera mnożenie tożsamości bieżącego typu.
IMultiplyOperators<IntPtr,IntPtr,IntPtr>.CheckedMultiply(IntPtr, IntPtr)	Mnoży dwie wartości, aby obliczyć swój produkt.
IMultiplyOperators<IntPtr,IntPtr,IntPtr>.Multiply(IntPtr, IntPtr)	Mnoży dwie wartości, aby obliczyć swój produkt.
INumber<IntPtr>.MaxNumber(IntPtr, IntPtr)	Porównuje dwie wartości z obliczeniami, które są większe i zwracają drugą wartość, jeśli dane wejściowe są NaN.
INumber<IntPtr>.MinNumber(IntPtr, IntPtr)	Porównuje dwie wartości z obliczeniami, które są mniejsze i zwracają drugą wartość, jeśli dane wejściowe są NaN.
INumberBase<IntPtr>.IsCanonical(IntPtr)	Określa, czy wartość znajduje się w jej kanonicznej reprezentacji.
INumberBase<IntPtr>.IsComplexNumber(IntPtr)	Określa, czy wartość reprezentuje liczbę zespolonej.
INumberBase<IntPtr>.IsFinite(IntPtr)	Określa, czy wartość jest skończona.
INumberBase<IntPtr>.IsImaginaryNumber(IntPtr)	Określa, czy wartość reprezentuje czystą liczbę wyimaginowaną.
INumberBase<IntPtr>.IsInfinity(IntPtr)	Określa, czy wartość jest nieskończona.
INumberBase<IntPtr>.IsInteger(IntPtr)	Określa, czy wartość reprezentuje liczbę całkowitą.
INumberBase<IntPtr>.IsNaN(IntPtr)	Określa, czy wartość to NaN.
INumberBase<IntPtr>.IsNegativeInfinity(IntPtr)	Określa, czy wartość jest ujemną nieskończonością.
INumberBase<IntPtr>.IsNormal(IntPtr)	Określa, czy wartość jest normalna.
INumberBase<IntPtr>.IsPositiveInfinity(IntPtr)	Określa, czy wartość jest dodatnią nieskończonością.
INumberBase<IntPtr>.IsRealNumber(IntPtr)	Określa, czy wartość reprezentuje liczbę rzeczywistą.
INumberBase<IntPtr>.IsSubnormal(IntPtr)	Określa, czy wartość jest nienormalna.
INumberBase<IntPtr>.IsZero(IntPtr)	Określa, czy wartość ma wartość zero.
INumberBase<IntPtr>.MaxMagnitudeNumber(IntPtr, IntPtr)	Porównuje dwie wartości z obliczeniami o większej wielkości i zwraca drugą wartość, jeśli dane wejściowe są NaN.
INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr, IntPtr)	Porównuje dwie wartości z obliczeniami o mniejszej wielkości i zwraca drugą wartość, jeśli dane wejściowe są NaN.
INumberBase<IntPtr>.One	Pobiera wartość 1 dla typu.
INumberBase<IntPtr>.Radix	Pobiera promienie lub podstawę dla typu.
INumberBase<IntPtr>.TryConvertFromChecked<TOther>(TOther, IntPtr)	Reprezentuje podpisaną liczbę całkowitą, w której szerokość bitów jest taka sama jak wskaźnik.
INumberBase<IntPtr>.TryConvertFromSaturating<TOther>(TOther, IntPtr)	Reprezentuje podpisaną liczbę całkowitą, w której szerokość bitów jest taka sama jak wskaźnik.
INumberBase<IntPtr>.TryConvertFromTruncating<TOther>(TOther, IntPtr)	Reprezentuje podpisaną liczbę całkowitą, w której szerokość bitów jest taka sama jak wskaźnik.
INumberBase<IntPtr>.TryConvertToChecked<TOther>(IntPtr, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, zgłaszając wyjątek przepełnienia dla wszystkich wartości, które mieszczą się poza dopuszczalnym zakresem bieżącego typu.
INumberBase<IntPtr>.TryConvertToSaturating<TOther>(IntPtr, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, saturując wszystkie wartości, które mieszczą się poza dopuszczalnym zakresem bieżącego typu.
INumberBase<IntPtr>.TryConvertToTruncating<TOther>(IntPtr, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, obcinając wszystkie wartości, które wykraczają poza reprezentowany zakres bieżącego typu.
INumberBase<IntPtr>.Zero	Pobiera wartość 0 dla typu.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Wypełnia obiekt SerializationInfo danymi potrzebnymi do serializacji bieżącego obiektu IntPtr.
IShiftOperators<IntPtr,Int32,IntPtr>.LeftShift(IntPtr, Int32)	Przesuwa wartość pozostawioną przez daną kwotę.
IShiftOperators<IntPtr,Int32,IntPtr>.RightShift(IntPtr, Int32)	Przesuwa wartość w prawo o daną kwotę.
IShiftOperators<IntPtr,Int32,IntPtr>.UnsignedRightShift(IntPtr, Int32)	Przesuwa wartość w prawo o daną kwotę.
ISignedNumber<IntPtr>.NegativeOne	Pobiera wartość -1 dla typu.
ISubtractionOperators<IntPtr,IntPtr,IntPtr>.CheckedSubtraction(IntPtr, IntPtr)	Odejmuje dwie wartości, aby obliczyć ich różnicę.
ISubtractionOperators<IntPtr,IntPtr,IntPtr>.Subtraction(IntPtr, IntPtr)	Odejmuje dwie wartości, aby obliczyć ich różnicę.
IUnaryNegationOperators<IntPtr,IntPtr>.CheckedUnaryNegation(IntPtr)	Oblicza sprawdzoną jednoargumentową negację wartości.
IUnaryNegationOperators<IntPtr,IntPtr>.UnaryNegation(IntPtr)	Oblicza jednoargumentowe negację wartości.
IUnaryPlusOperators<IntPtr,IntPtr>.UnaryPlus(IntPtr)	Oblicza jednoargumentowy plus wartość.

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkiem.

Zobacz też

• UIntPtr