IntPtr Struktura

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Źródło:

IntPtr.cs

Reprezentuje liczbę całkowitą ze znakiem, 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, aby odwrócić znaki w tablicy. Po zainicjowaniu String obiektu 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 IntPtr obiekt wskazujący początek niezarządzanego ciągu. W przykładzie języka Visual Basic ten wskaźnik jest używany 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 w celu przydzielenia tej samej liczby bajtów co niezarządzany ciąg zajmuje. Metoda zwraca IntPtr obiekt wskazujący początek niezarządzanego bloku pamięci. W przykładzie języka Visual Basic ten wskaźnik jest używany 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 jest długością ciągu, operacja kopiowania skopiuje znak od początku ciągu do końca bloku pamięci.

   Przykłady języków C#, F# i C++ wywołają ToPointer metodę , aby uzyskać niezarządzany wskaźnik do adresu początkowego ciągu i niezarządzanego bloku pamięci, a następnie dodają jedną mniej niż długość ciągu do adresu początkowego ciągu ANSI. Ponieważ niezarządzany wskaźnik ciągu wskazuje teraz 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) , aby odczytać bajt (lub znak jednobajtowy) przy określonym przesunięciu z zarządzanego wskaźnika do ciągu ANSI. Przesunięcie jest zwiększane wraz 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 offsetwartość .

   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 bloku niezarządzanym.

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

6. Po wyświetleniu oryginalnych i odwróconych ciągów wszystkie przykłady wywołają FreeHGlobal metodę , 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-bitowe w procesie 64-bitowym.

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

IntPtr obiekty mogą być również używane do przechowywania dojść. Na przykład wystąpienia klasy IntPtr są szeroko używane w System.IO.FileStream klasie do przechowywania dojść do plików.

Uwaga

Użycie 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 służyć 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 powinny być używane do reprezentowania dojść.

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

W języku C# począwszy od wersji 9.0 można użyć wbudowanego nint typu do zdefiniowania liczb całkowitych o rozmiarze natywnym. Ten typ jest reprezentowany przez IntPtr typ 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 ( Typy nint i nuint).

W języku C# począwszy od wersji 11 i w przypadku określania wartości docelowej środowiska uruchomieniowego nint .NET 7 lub nowszego alias jest aliasem intIntPtr dla .Int32

Konstruktory

IntPtr(Int32)	Inicjuje IntPtr nowe wystąpienie przy użyciu określonej 32-bitowej liczby całkowitej ze znakiem.
IntPtr(Int64)	Inicjuje IntPtr nowe wystąpienie przy użyciu określonej 64-bitowej liczby całkowitej ze znakiem.
IntPtr(Void*)	Inicjuje nowe wystąpienie IntPtr użycia 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ą, która wskazuje, czy bieżące wystąpienie poprzedza, następuje po lub występuje w tym samym położeniu, co inny obiekt w porządku sortowania.
CompareTo(Object)	Porównuje bieżące wystąpienie z innym obiektem tego samego typu i zwraca liczbę całkowitą, która wskazuje, czy bieżące wystąpienie poprzedza, następuje po lub występuje w tym samym położeniu, co inny obiekt w porządku sortowania.
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 wykraczają poza dopuszczalny zakres 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 znajdują się poza dopuszczalnym zakresem 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 podanemu obiektowi.
GetHashCode()	Zwraca wartość 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 nieparzystą 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 do obliczeń, które są większe.
MaxMagnitude(IntPtr, IntPtr)	Porównuje dwie wartości do obliczeń, które są większe.
Min(IntPtr, IntPtr)	Porównuje dwie wartości do obliczeń, które są mniejsze.
MinMagnitude(IntPtr, IntPtr)	Porównuje dwie wartości do obliczeń, które są mniejsze.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analizuje zakres znaków UTF-8 w wartości.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analizuje zakres znaków UTF-8 w wartości.
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 odpowiednik natywnej liczby całkowitej ze znakiem.
Parse(String)	Konwertuje reprezentację ciągu liczby na jej odpowiednik natywnej liczby całkowitej ze znakiem.
Parse(String, IFormatProvider)	Konwertuje reprezentację ciągu liczby w określonym formacie specyficznym dla kultury na jej podpisaną natywną liczbę całkowitą równoważną.
Parse(String, NumberStyles)	Konwertuje reprezentację ciągu liczby w określonym stylu na jej odpowiednik natywnej liczby całkowitej ze znakiem.
Parse(String, NumberStyles, IFormatProvider)	Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na jej 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 od 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 IntPtr obiektu na równoważną reprezentację ciągu.
ToString(IFormatProvider)	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację w postaci ciągu przy użyciu podanego formatu i informacji specyficznych dla kultury.
ToString(String)	Konwertuje wartość liczbową bieżącego IntPtr obiektu 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ści.
TryParse(ReadOnlySpan<Byte>, IntPtr)	Próbuje przekonwertować zakres znaków UTF-8 zawierający reprezentację ciągu liczby na odpowiednik ze znakiem liczby całkowitej.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, IntPtr)	Próbuje przeanalizować zakres znaków UTF-8 w wartości.
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 ich natywną liczbę całkowitą. 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 odpowiednik natywnej liczby całkowitej ze znakiem. 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 jej odpowiednik natywnej liczby całkowitej ze znakiem. 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 jej 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 adresu IntPtr są takie same.
Explicit(Int32 to IntPtr)	Konwertuje wartość 32-bitowej liczby całkowitej ze znakiem na wartość IntPtr.
Explicit(Int64 to IntPtr)	Konwertuje wartość 64-bitowej liczby całkowitej ze znakiem na wartość 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 liczby całkowitej ze znakiem 64-bitowym.
Explicit(IntPtr to Void*)	Konwertuje wartość określonego IntPtr wskaźnika 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 elementu IntPtr nie są takie same.
Subtraction(IntPtr, Int32)	Odejmuje przesunięcie od 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 jako część .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 liczbę całkowitą ze znakiem, w której szerokość bitów jest taka sama jak wskaźnik.
IBinaryInteger<IntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	Reprezentuje liczbę całkowitą ze znakiem, 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 dla 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 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 jedynek.
IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThan(IntPtr, IntPtr)	Porównuje dwie wartości, aby określić, które wartości są większe.
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 tożsamość mnożenia 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 do obliczeń, które są większe i zwracają drugą wartość, jeśli dane wejściowe to NaN.
INumber<IntPtr>.MinNumber(IntPtr, IntPtr)	Porównuje dwie wartości do obliczeń, które są mniejsze i zwracają drugą wartość, jeśli dane wejściowe to NaN.
INumberBase<IntPtr>.IsCanonical(IntPtr)	Określa, czy wartość znajduje się w jego reprezentacji kanonicznej.
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 nieskończonością ujemną.
INumberBase<IntPtr>.IsNormal(IntPtr)	Określa, czy wartość jest normalna.
INumberBase<IntPtr>.IsPositiveInfinity(IntPtr)	Określa, czy wartość jest nieskończonością dodatnią.
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 do obliczeń, które mają większą wielkość i zwracają drugą wartość, jeśli dane wejściowe to NaN.
INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr, IntPtr)	Porównuje dwie wartości do obliczeń, które mają mniejszą wielkość i zwracają drugą wartość, jeśli dane wejściowe to NaN.
INumberBase<IntPtr>.One	Pobiera wartość 1 typu.
INumberBase<IntPtr>.Radix	Pobiera promień lub bazę dla typu .
INumberBase<IntPtr>.TryConvertFromChecked<TOther>(TOther, IntPtr)	Reprezentuje liczbę całkowitą ze znakiem, w której szerokość bitów jest taka sama jak wskaźnik.
INumberBase<IntPtr>.TryConvertFromSaturating<TOther>(TOther, IntPtr)	Reprezentuje liczbę całkowitą ze znakiem, w której szerokość bitów jest taka sama jak wskaźnik.
INumberBase<IntPtr>.TryConvertFromTruncating<TOther>(TOther, IntPtr)	Reprezentuje liczbę całkowitą ze znakiem, 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 wykraczają poza dopuszczalny zakres 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 wykraczają poza dopuszczalny zakres 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 dopuszczalny zakres bieżącego typu.
INumberBase<IntPtr>.Zero	Pobiera wartość 0 typu.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	SerializationInfo Wypełnia obiekt danymi potrzebnymi do serializacji bieżącego IntPtr obiektu.
IShiftOperators<IntPtr,Int32,IntPtr>.LeftShift(IntPtr, Int32)	Przesuwa wartość w lewo o 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 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ątkowo.

Zobacz też

• UIntPtr