IntPtr Struktura

Definicja

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

public value class IntPtr
public value class IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, System::Runtime::Serialization::ISerializable
public value class IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, ISpanFormattable, System::Runtime::Serialization::ISerializable
public value class IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<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>, System::Numerics::IDecrementOperators<IntPtr>, System::Numerics::IDivisionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IEqualityOperators<IntPtr, IntPtr>, 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, 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 value class IntPtr : IEquatable<IntPtr>, System::Runtime::Serialization::ISerializable
public value class IntPtr : System::Runtime::Serialization::ISerializable
public struct IntPtr
public readonly struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, System.Runtime.Serialization.ISerializable
public readonly struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, ISpanFormattable, System.Runtime.Serialization.ISerializable
public readonly struct IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<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>, System.Numerics.IDecrementOperators<IntPtr>, System.Numerics.IDivisionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IEqualityOperators<IntPtr,IntPtr>, 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,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 struct IntPtr : IEquatable<IntPtr>, System.Runtime.Serialization.ISerializable
public readonly struct IntPtr : IEquatable<IntPtr>, System.Runtime.Serialization.ISerializable
[System.Serializable]
public struct IntPtr : System.Runtime.Serialization.ISerializable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct IntPtr : System.Runtime.Serialization.ISerializable
public struct IntPtr : System.Runtime.Serialization.ISerializable
type nativeint = struct
type nativeint = struct
    interface IFormattable
    interface ISerializable
type nativeint = struct
    interface ISpanFormattable
    interface IFormattable
    interface 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>
    interface IEqualityOperators<nativeint, nativeint>
    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 IShiftOperators<nativeint, nativeint>
    interface IMinMaxValue<nativeint>
    interface ISignedNumber<nativeint>
    interface ISerializable
type nativeint = struct
    interface ISerializable
[<System.Serializable>]
type nativeint = struct
    interface ISerializable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type nativeint = struct
    interface ISerializable
Public Structure IntPtr
Public Structure IntPtr
Implements IComparable, IComparable(Of IntPtr), IEquatable(Of IntPtr), IFormattable, ISerializable
Public Structure IntPtr
Implements IComparable, IComparable(Of IntPtr), IEquatable(Of IntPtr), ISerializable, ISpanFormattable
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), IDecrementOperators(Of IntPtr), IDivisionOperators(Of IntPtr, IntPtr, IntPtr), IEqualityOperators(Of IntPtr, IntPtr), 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, IntPtr), ISignedNumber(Of IntPtr), ISpanParsable(Of IntPtr), ISubtractionOperators(Of IntPtr, IntPtr, IntPtr), IUnaryNegationOperators(Of IntPtr, IntPtr), IUnaryPlusOperators(Of IntPtr, IntPtr)
Public Structure IntPtr
Implements IEquatable(Of IntPtr), ISerializable
Public Structure IntPtr
Implements ISerializable
Dziedziczenie
IntPtr
Atrybuty
Implementuje
IComparable IComparable<IntPtr> IEquatable<IntPtr> IFormattable ISerializable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> 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> System.Numerics.IComparisonOperators<IntPtr,IntPtr> System.Numerics.IComparisonOperators<TSelf,TSelf> IDecrementOperators<IntPtr> IDecrementOperators<TSelf> IDivisionOperators<IntPtr,IntPtr,IntPtr> IDivisionOperators<TSelf,TSelf,TSelf> System.Numerics.IEqualityOperators<IntPtr,IntPtr> System.Numerics.IEqualityOperators<TSelf,TOther> System.Numerics.IEqualityOperators<TSelf,TSelf> 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> System.Numerics.IShiftOperators<IntPtr,IntPtr> System.Numerics.IShiftOperators<TSelf,TSelf> ISignedNumber<IntPtr> ISubtractionOperators<IntPtr,IntPtr,IntPtr> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<IntPtr,IntPtr> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<IntPtr,IntPtr> IUnaryPlusOperators<TSelf,TSelf>

Przykłady

W poniższym przykładzie użyto wskaźników zarządzanych do odwrócenia znaków 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 użyto tego wskaźnika bezpośrednio; w przykładach C++, F# i C# jest rzutowany do wskaźnika na bajt.

  2. Wywołuje metodę Marshal.AllocHGlobal w celu przydzielenia tej samej liczby bajtów co ciąg niezarządzany. Metoda zwraca IntPtr obiekt wskazujący początek niezarządzanego bloku pamięci. W przykładzie języka Visual Basic użyto tego wskaźnika bezpośrednio; w przykładach C++, F# i C# jest rzutowany do wskaźnika na bajt.

  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++ nazywają ToPointer metodę , aby uzyskać wskaźnik niezarządzany na adres początkowy ciągu i niezarządzany blok pamięci, a następnie dodają jeden mniejszy niż długość ciągu do adresu początkowego ciągu ANSI. Ponieważ wskaźnik ciągu niezarządzanego wskazuje teraz na koniec ciągu, operacja kopiowania skopiuje znak z końca ciągu do początku 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) odczytu bajtu (lub znaku jednobajtowego) w określonym przesunięciu 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) zapisu bajtu 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ę w celu zwolnienia pamięci przydzielonej 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-bitowym 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 uchwytów. Na przykład wystąpienia klasy IntPtr są szeroko używane do System.IO.FileStream 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 być używany jako format wymiany wskaźników i uchwytów z powodu tego samego rozmiaru. Poza określonymi wymaganiami wymiany, takimi jak przekazywanie danych do języka, który nie obsługuje wskaźników, należy używać poprawnie wpisanego wskaźnika do reprezentowania wskaźników i SafeHandle służyć do reprezentowania dojść.

Ten typ implementuje element ISerializable. W wersjach .NET 5 i nowszych ten typ implementuje IFormattable również interfejsy. W wersjach .NET 7 i nowszych 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 int IntPtr dla Int32programu .

Konstruktory

IntPtr(Int32)

Inicjuje IntPtr nowe wystąpienie przy użyciu określonej 32-bitowej liczby całkowitej z podpisem.

IntPtr(Int64)

Inicjuje IntPtr nowe wystąpienie przy użyciu określonej 64-bitowej liczby całkowitej z podpisem.

IntPtr(Void*)

Inicjuje IntPtr nowe wystąpienie 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 do zera.

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.

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 parzystą liczbę całkowitą.

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 mocą 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<Char>, IFormatProvider)
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 natywną liczbę całkowitą ze znakiem.

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 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<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Próbuje sformatować wartość bieżącego wystąpienia w podanym zakresie znaków.

TryParse(ReadOnlySpan<Char>, IFormatProvider, IntPtr)
TryParse(ReadOnlySpan<Char>, IntPtr)

Konwertuje zakres znaków tylko do odczytu z reprezentacją liczby 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 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)
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 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 liczby całkowitej z podpisem 32-bitowym.

Explicit(IntPtr to Int64)

Konwertuje wartość określonej IntPtr liczby całkowitej z podpisem 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 z podpisanej liczby całkowitej.

Jawne implementacje interfejsu

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>.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.

IEquatable<IntPtr>.Equals(IntPtr)

Zwraca wartość wskazującą, czy to wystąpienie jest równe innej podpisanej liczbie całkowitej.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

SerializationInfo Wypełnia obiekt danymi potrzebnymi do serializacji bieżącego IntPtr obiektu.

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.

Zobacz też