IntPtr Yapı

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kod:

System.Runtime.dll

Kaynak:

IntPtr.cs

bit genişliğinin işaretçiyle aynı olduğu işaretli bir tamsayıyı temsil eder.

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)

Devralma

Object

ValueType

IntPtr

Uygulamalar

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>

Örnekler

Aşağıdaki örnek, bir dizideki karakterleri ters çevirmek için yönetilen işaretçileri kullanır. bir String nesnesi başlatıp uzunluğunu aldıktan sonra aşağıdakileri yapar:

1. Unicode dizesini yönetilmeyen belleğe ANSI (tek bayt) karakteri olarak kopyalamak için Marshal.StringToHGlobalAnsi yöntemini çağırır. yöntemi, yönetilmeyen dizenin başına işaret eden bir IntPtr nesnesi döndürür. Visual Basic örneği bu işaretçiyi doğrudan kullanır; C++, F# ve C# örneklerinde bir bayt işaretçisine geçirilir.

2. Yönetilmeyen dizenin kapladıkça aynı sayıda bayt ayırmak için Marshal.AllocHGlobal yöntemini çağırır. yöntemi, yönetilmeyen bellek bloğunun başlangıcına işaret eden bir IntPtr nesnesi döndürür. Visual Basic örneği bu işaretçiyi doğrudan kullanır; C++, F# ve C# örneklerinde bir bayt işaretçisine geçirilir.

3. Visual Basic örneği, ANSI dizesinin uzunluğuna eşit offset adlı bir değişken tanımlar. ANSI dizesindeki bir sonraki karakterin kopyalandığı yönetilmeyen belleğe uzaklığı belirlemek için kullanılır. Başlangıç değeri dizenin uzunluğu olduğundan, kopyalama işlemi dizenin başından bellek bloğunun sonuna bir karakter kopyalar.

   C#, F# ve C++ örnekleri, dizenin başlangıç adresine ve yönetilmeyen bellek bloğuna yönetilmeyen bir işaretçi almak için ToPointer yöntemini çağırır ve ANSI dizesinin başlangıç adresine dizenin uzunluğundan daha az bir işaretçi ekler. Yönetilmeyen dize işaretçisi artık dizenin sonuna işaret ettiğinden, kopyalama işlemi dizenin sonundan bellek bloğunun başlangıcına bir karakter kopyalar.

4. Dizedeki her karakteri yönetilmeyen bellek bloğuna kopyalamak için bir döngü kullanır.

   Visual Basic örneği, yönetilen işaretçiden ANSI dizesine belirtilen uzaklıkta bayt (veya tek baytlık karakter) okumak için Marshal.ReadByte(IntPtr, Int32) yöntemini çağırır. Uzaklık, döngünün her yinelemesiyle artırılır. Ardından Marshal.WriteByte(IntPtr, Int32, Byte) yöntemini çağırarak yönetilmeyen bellek bloğunun başlangıç adresi ve offsettarafından tanımlanan bellek adresine bayt yazar. Ardından offsetazalmış olur.

   C#, F# ve C++ örnekleri kopyalama işlemini gerçekleştirir, ardından işaretçiyi yönetilmeyen ANSI dizesindeki bir sonraki konumun adresine kadar azaltıp işaretçiyi yönetilmeyen bloktaki bir sonraki adrese yükseltir.

5. Tüm örnekler, kopyalanan ANSI dizesini içeren yönetilmeyen bellek bloğunu yönetilen bir Unicode String nesnesine dönüştürmek için Marshal.PtrToStringAnsi çağırır.

6. Özgün ve ters çevrilmiş dizeleri görüntüledikten sonra, tüm örnekler yönetilmeyen ANSI dizesi ve yönetilmeyen bellek bloğu için ayrılan belleği boşaltmak için FreeHGlobal yöntemini çağırır.

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

Açıklamalar

IntPtr türü, boyutu işaretçiyle aynı olan bir tamsayı olacak şekilde tasarlanmıştır. Yani, bu tür bir örneğinin 32 bit işlemde 32 bit ve 64 bit işlemde 64 bit olması beklenir.

IntPtr türü, işaretçileri destekleyen diller tarafından ve işaretçileri destekleyen ve desteklemeyen diller arasındaki verilere başvurmanın yaygın bir aracı olarak kullanılabilir.

IntPtr nesneleri tutamaçları tutmak için de kullanılabilir. Örneğin, IntPtr örnekleri, dosya tanıtıcılarını tutmak için System.IO.FileStream sınıfında kapsamlı olarak kullanılır.

Not

IntPtr işaretçi veya tanıtıcı olarak kullanmak hataya açıktır ve güvenli değildir. Aynı boyutta olması nedeniyle işaretçiler ve tanıtıcılar için değişim biçimi olarak kullanılabilen bir tamsayı türüdür. İşaretçileri desteklemeyen bir dile veri geçirme gibi belirli değişim gereksinimleri dışında, işaretçileri temsil etmek için doğru yazılan bir işaretçi ve tanıtıcıları göstermek için SafeHandle kullanılmalıdır.

Bu tür ISerializableuygular. .NET 5 ve sonraki sürümlerde, bu tür IFormattable arabirimlerini de uygular. .NET 7 ve sonraki sürümlerde, bu tür IBinaryInteger<TSelf>, IMinMaxValue<TSelf>ve ISignedNumber<TSelf> arabirimlerini de uygular.

9.0 sürümünden başlayarak C# dilinde, yerel boyutlu tamsayıları tanımlamak için yerleşik nint türünü kullanabilirsiniz. Bu tür, IntPtr türüyle dahili olarak temsil edilir ve tamsayı türleri için uygun işlemler ve dönüştürmeler sağlar. Daha fazla bilgi için bkz. nint ve nuint türleri.

C# sürümünde sürüm 11'den başlayarak .NET 7 veya üzeri çalışma zamanını hedeflerken nint, intInt32için diğer ad olduğu gibi IntPtr için de bir diğer addır.

Oluşturucular

IntPtr(Int32)	Belirtilen 32 bit imzalı tamsayıyı kullanarak yeni bir IntPtr örneği başlatır.
IntPtr(Int64)	Belirtilen 64 bit imzalı tamsayıyı kullanarak yeni bir IntPtr örneği başlatır.
IntPtr(Void*)	Belirtilmemiş bir tür için belirtilen işaretçiyi kullanarak yeni bir IntPtr örneği başlatır.

Alanlar

Zero	Sıfıra başlatılan imzalı bir tamsayıyı temsil eden salt okunur alan.

Özellikler

MaxValue	mümkün olan en büyük IntPtrdeğerini alır.
MinValue	IntPtren küçük olası değerini alır.
Size	Bu örneğin boyutunu alır.

Yöntemler

Abs(IntPtr)	Bir değerin mutlak değerini hesaplar.
Add(IntPtr, Int32)	İmzalı tamsayıya uzaklık ekler.
Clamp(IntPtr, IntPtr, IntPtr)	Bir değeri kapsayıcı en düşük ve en yüksek değere kelepçeler.
CompareTo(IntPtr)	Geçerli örneği aynı türdeki başka bir nesneyle karşılaştırır ve geçerli örneğin diğer nesneyle aynı sıralama düzeninde önce geldiğini, izlediğini veya yine aynı konumda yer alıp almadığını belirten bir tamsayı döndürür.
CompareTo(Object)	Geçerli örneği aynı türdeki başka bir nesneyle karşılaştırır ve geçerli örneğin diğer nesneyle aynı sıralama düzeninde önce geldiğini, izlediğini veya yine aynı konumda yer alıp almadığını belirten bir tamsayı döndürür.
CopySign(IntPtr, IntPtr)	Bir değerin işaretini başka bir değerin işaretine kopyalar.
CreateChecked<TOther>(TOther)	Geçerli türün bir örneğini bir değerden oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan değerler için taşma özel durumu oluşturur.
CreateSaturating<TOther>(TOther)	Bir değerden geçerli türün bir örneğini oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan tüm değerleri doygun hale getirir.
CreateTruncating<TOther>(TOther)	Geçerli türün bir örneğini bir değerden oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan değerleri kesebilir.
DivRem(IntPtr, IntPtr)	İki değerin bölümünü ve kalan bölümünü hesaplar.
Equals(IntPtr)	Geçerli nesnenin aynı türdeki başka bir nesneye eşit olup olmadığını gösterir.
Equals(Object)	Bu örneğin belirtilen bir nesneye eşit olup olmadığını gösteren bir değer döndürür.
GetHashCode()	Bu örneğin karma kodunu döndürür.
IsEvenInteger(IntPtr)	Bir değerin çift tamsayı sayıyı temsil eder olup olmadığını belirler.
IsNegative(IntPtr)	Bir değerin negatif olup olmadığını belirler.
IsOddInteger(IntPtr)	Bir değerin tek bir tamsayı sayısını temsil ediyor olup olmadığını belirler.
IsPositive(IntPtr)	Bir değerin pozitif olup olmadığını belirler.
IsPow2(IntPtr)	Bir değerin ikinin gücü olup olmadığını belirler.
LeadingZeroCount(IntPtr)	Bir değerdeki baştaki sıfırların sayısını hesaplar.
Log2(IntPtr)	Bir değerin 2. günlüğünü hesaplar.
Max(IntPtr, IntPtr)	daha büyük olan iki değeri işlemle karşılaştırır.
MaxMagnitude(IntPtr, IntPtr)	daha büyük olan iki değeri işlemle karşılaştırır.
Min(IntPtr, IntPtr)	daha az olan iki değeri işlemle karşılaştırır.
MinMagnitude(IntPtr, IntPtr)	daha az olan iki değeri işlemle karşılaştırır.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	UTF-8 karakterlik bir aralığı bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	UTF-8 karakterlik bir aralığı bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Bir karakter aralığını bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Bir sayının belirtilen stilde ve kültüre özgü biçimdeki karakter gösteriminin salt okunur aralığını imzalı yerel tamsayı eşdeğerine dönüştürür.
Parse(String)	Bir sayının dize gösterimini imzalı yerel tamsayı eşdeğerine dönüştürür.
Parse(String, IFormatProvider)	Belirli bir kültüre özgü biçimdeki bir sayının dize gösterimini imzalı yerel tamsayı eşdeğerine dönüştürür.
Parse(String, NumberStyles)	Belirtilen stildeki bir sayının dize gösterimini imzalı yerel tamsayı eşdeğerine dönüştürür.
Parse(String, NumberStyles, IFormatProvider)	Belirtilen stilde ve kültüre özgü biçimdeki bir sayının dize gösterimini imzalı yerel tamsayı eşdeğerine dönüştürür.
PopCount(IntPtr)	Bir değerde ayarlanan bit sayısını hesaplar.
RotateLeft(IntPtr, Int32)	Değeri belirli bir miktar sola döndürür.
RotateRight(IntPtr, Int32)	Değeri belirli bir miktara göre sağa döndürür.
Sign(IntPtr)	Bir değerin işaretini hesaplar.
Subtract(IntPtr, Int32)	İşaretli tamsayıdan uzaklığı çıkarır.
ToInt32()	Bu örneğin değerini 32 bit imzalı tamsayıya dönüştürür.
ToInt64()	Bu örneğin değerini 64 bit imzalı tamsayıya dönüştürür.
ToPointer()	Bu örneğin değerini belirtilmemiş bir türe işaretçiye dönüştürür.
ToString()	Geçerli IntPtr nesnesinin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(IFormatProvider)	Belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak bu örneğin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(String)	Geçerli IntPtr nesnesinin sayısal değerini eşdeğer dize gösterimine dönüştürür.
ToString(String, IFormatProvider)	Belirtilen biçimi kullanarak geçerli örneğin değerini biçimlendirin.
TrailingZeroCount(IntPtr)	Bir değerdeki sondaki sıfırların sayısını hesaplar.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli örneğin değerini UTF-8 olarak sağlanan bayt aralığına biçimlendirmeye çalışır.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli örneğin değerini sağlanan karakter aralığına biçimlendirmeye çalışır.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, IntPtr)	UTF-8 karakterlik bir aralığı bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Byte>, IntPtr)	Bir sayının dize gösterimini içeren UTF-8 karakter aralığını imzalı tamsayı eşdeğerine dönüştürmeye çalışır.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, IntPtr)	UTF-8 karakterlik bir aralığı bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Char>, IFormatProvider, IntPtr)	Bir dizeyi bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Char>, IntPtr)	Bir sayının karakter gösteriminin salt okunur aralığını imzalı yerel tamsayı eşdeğerine dönüştürür. Dönüş değeri, dönüştürmenin başarılı olup olmadığını gösterir.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, IntPtr)	Bir sayının belirtilen stilde ve kültüre özgü biçimdeki karakter gösteriminin salt okunur aralığını imzalı yerel tamsayı eşdeğerine dönüştürür. Dönüş değeri, dönüştürmenin başarılı olup olmadığını gösterir.
TryParse(String, IFormatProvider, IntPtr)	Bir dizeyi bir değere ayrıştırmaya çalışır.
TryParse(String, IntPtr)	Bir sayının dize gösterimini imzalı yerel tamsayı eşdeğerine dönüştürür. Dönüş değeri, dönüştürmenin başarılı olup olmadığını gösterir.
TryParse(String, NumberStyles, IFormatProvider, IntPtr)	Belirtilen stilde ve kültüre özgü biçimdeki bir sayının dize gösterimini imzalı yerel tamsayı eşdeğerine dönüştürür. Dönüş değeri, dönüştürmenin başarılı olup olmadığını gösterir.

İşleçler

Addition(IntPtr, Int32)	İmzalı tamsayıya uzaklık ekler.
Equality(IntPtr, IntPtr)	Belirtilen iki IntPtr örneğinin eşit olup olmadığını belirler.
Explicit(Int32 to IntPtr)	32 bit imzalı tamsayı değerini IntPtrdönüştürür.
Explicit(Int64 to IntPtr)	64 bit imzalı tamsayı değerini IntPtrdönüştürür.
Explicit(IntPtr to Int32)	Belirtilen IntPtr değerini 32 bit imzalı tamsayıya dönüştürür.
Explicit(IntPtr to Int64)	Belirtilen IntPtr değerini 64 bit imzalı tamsayıya dönüştürür.
Explicit(IntPtr to Void*)	Belirtilen IntPtr değerini belirtilmemiş bir türe işaretçiye dönüştürür. Bu API CLS uyumlu değil.
Explicit(Void* to IntPtr)	Belirtilen işaretçiyi belirtilmemiş bir türe IntPtrdönüştürür. Bu API CLS uyumlu değil.
Inequality(IntPtr, IntPtr)	belirtilen iki IntPtr örneğinin eşit olup olmadığını belirler.
Subtraction(IntPtr, Int32)	İşaretli tamsayıdan uzaklığı çıkarır.

Belirtik Arabirim Kullanımları

IAdditionOperators<IntPtr,IntPtr,IntPtr>.Addition(IntPtr, IntPtr)	Toplamlarını hesaplamak için iki değeri bir araya ekler.
IAdditionOperators<IntPtr,IntPtr,IntPtr>.CheckedAddition(IntPtr, IntPtr)	Toplamlarını hesaplamak için iki değeri bir araya ekler.
IAdditiveIdentity<IntPtr,IntPtr>.AdditiveIdentity	Geçerli türün ek kimliğini alır.
IBinaryInteger<IntPtr>.GetByteCount()	TryWriteLittleEndian(Span<Byte>, Int32)parçası olarak yazılacak bayt sayısını alır.
IBinaryInteger<IntPtr>.GetShortestBitLength()	Geçerli değerin en kısa ikisinin tamamlayıcı gösteriminin bit cinsinden uzunluğunu alır.
IBinaryInteger<IntPtr>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	bit genişliğinin işaretçiyle aynı olduğu işaretli bir tamsayıyı temsil eder.
IBinaryInteger<IntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	bit genişliğinin işaretçiyle aynı olduğu işaretli bir tamsayıyı temsil eder.
IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<Byte>, Int32)	Geçerli değeri büyük endian biçiminde belirli bir span'a yazmaya çalışır.
IBinaryInteger<IntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)	Geçerli değeri küçük endian biçiminde belirli bir span'a yazmaya çalışır.
IBinaryNumber<IntPtr>.AllBitsSet	Tüm bitlerin ayarlandığı ikili türün bir örneğini alır.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseAnd(IntPtr, IntPtr)	İki değerin bit düzeyinde ve değerini hesaplar.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseOr(IntPtr, IntPtr)	bit düzeyinde veya iki değeri hesaplar.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.ExclusiveOr(IntPtr, IntPtr)	İki değerin özel veya özel değerini hesaplar.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.OnesComplement(IntPtr)	Belirli bir değerin bire tamamlayan gösterimini hesaplar.
IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThan(IntPtr, IntPtr)	Hangisinin daha büyük olduğunu belirlemek için iki değeri karşılaştırır.
IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThanOrEqual(IntPtr, IntPtr)	Hangisinin daha büyük veya eşit olduğunu belirlemek için iki değeri karşılaştırır.
IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThan(IntPtr, IntPtr)	Hangisinin daha az olduğunu belirlemek için iki değeri karşılaştırır.
IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThanOrEqual(IntPtr, IntPtr)	Hangisinin daha az veya eşit olduğunu belirlemek için iki değeri karşılaştırır.
IDecrementOperators<IntPtr>.CheckedDecrement(IntPtr)	Bir değeri azaltma.
IDecrementOperators<IntPtr>.Decrement(IntPtr)	Bir değeri azaltma.
IDivisionOperators<IntPtr,IntPtr,IntPtr>.Division(IntPtr, IntPtr)	Kendi bölümünü hesaplamak için bir değeri diğerine böler.
IIncrementOperators<IntPtr>.CheckedIncrement(IntPtr)	Bir değeri artırır.
IIncrementOperators<IntPtr>.Increment(IntPtr)	Bir değeri artırır.
IMinMaxValue<IntPtr>.MaxValue	Geçerli türün en büyük değerini alır.
IMinMaxValue<IntPtr>.MinValue	Geçerli türün en düşük değerini alır.
IModulusOperators<IntPtr,IntPtr,IntPtr>.Modulus(IntPtr, IntPtr)	Modüllerini veya kalan değerlerini hesaplamak için iki değeri birbirine böler.
IMultiplicativeIdentity<IntPtr,IntPtr>.MultiplicativeIdentity	Geçerli türün çarpımlı kimliğini alır.
IMultiplyOperators<IntPtr,IntPtr,IntPtr>.CheckedMultiply(IntPtr, IntPtr)	Ürünlerini hesaplamak için iki değeri bir araya getiren.
IMultiplyOperators<IntPtr,IntPtr,IntPtr>.Multiply(IntPtr, IntPtr)	Ürünlerini hesaplamak için iki değeri bir araya getiren.
INumber<IntPtr>.MaxNumber(IntPtr, IntPtr)	daha büyük olan ve giriş NaNdiğer değeri döndüren iki değeri işlemle karşılaştırır.
INumber<IntPtr>.MinNumber(IntPtr, IntPtr)	daha küçük olan ve giriş NaNdiğer değeri döndüren iki değeri işlemle karşılaştırır.
INumberBase<IntPtr>.IsCanonical(IntPtr)	Bir değerin kurallı gösteriminde olup olmadığını belirler.
INumberBase<IntPtr>.IsComplexNumber(IntPtr)	Bir değerin karmaşık bir sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<IntPtr>.IsFinite(IntPtr)	Bir değerin sonlu olup olmadığını belirler.
INumberBase<IntPtr>.IsImaginaryNumber(IntPtr)	Bir değerin saf bir sanal sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<IntPtr>.IsInfinity(IntPtr)	Bir değerin sonsuz olup olmadığını belirler.
INumberBase<IntPtr>.IsInteger(IntPtr)	Bir değerin tam sayı olup olmadığını belirler.
INumberBase<IntPtr>.IsNaN(IntPtr)	Bir değerin NaN olup olmadığını belirler.
INumberBase<IntPtr>.IsNegativeInfinity(IntPtr)	Bir değerin negatif sonsuz olup olmadığını belirler.
INumberBase<IntPtr>.IsNormal(IntPtr)	Bir değerin normal olup olmadığını belirler.
INumberBase<IntPtr>.IsPositiveInfinity(IntPtr)	Bir değerin pozitif sonsuz olup olmadığını belirler.
INumberBase<IntPtr>.IsRealNumber(IntPtr)	Bir değerin gerçek bir sayıyı temsil ediyor olup olmadığını belirler.
INumberBase<IntPtr>.IsSubnormal(IntPtr)	Bir değerin normalin altında olup olmadığını belirler.
INumberBase<IntPtr>.IsZero(IntPtr)	Değerin sıfır olup olmadığını belirler.
INumberBase<IntPtr>.MaxMagnitudeNumber(IntPtr, IntPtr)	daha büyük bir büyüklüğe sahip olan ve giriş NaNdiğer değeri döndüren iki değeri işlemle karşılaştırır.
INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr, IntPtr)	daha az büyüklüğe sahip olan ve giriş NaNdiğer değeri döndüren iki değeri işlemle karşılaştırır.
INumberBase<IntPtr>.One	Türün 1 değerini alır.
INumberBase<IntPtr>.Radix	Türün radiksini veya tabanını alır.
INumberBase<IntPtr>.TryConvertFromChecked<TOther>(TOther, IntPtr)	bit genişliğinin işaretçiyle aynı olduğu işaretli bir tamsayıyı temsil eder.
INumberBase<IntPtr>.TryConvertFromSaturating<TOther>(TOther, IntPtr)	bit genişliğinin işaretçiyle aynı olduğu işaretli bir tamsayıyı temsil eder.
INumberBase<IntPtr>.TryConvertFromTruncating<TOther>(TOther, IntPtr)	bit genişliğinin işaretçiyle aynı olduğu işaretli bir tamsayıyı temsil eder.
INumberBase<IntPtr>.TryConvertToChecked<TOther>(IntPtr, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan değerler için bir taşma özel durumu oluşturur.
INumberBase<IntPtr>.TryConvertToSaturating<TOther>(IntPtr, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan değerleri doygunluğa getirir.
INumberBase<IntPtr>.TryConvertToTruncating<TOther>(IntPtr, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeye çalışır ve geçerli türün temsil edilebilir aralığının dışında kalan tüm değerleri kısaltır.
INumberBase<IntPtr>.Zero	Türün 0 değerini alır.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	bir SerializationInfo nesnesini geçerli IntPtr nesnesini seri hale getirmek için gereken verilerle doldurur.
IShiftOperators<IntPtr,Int32,IntPtr>.LeftShift(IntPtr, Int32)	Değeri belirli bir miktar sola kaydırıyor.
IShiftOperators<IntPtr,Int32,IntPtr>.RightShift(IntPtr, Int32)	Değeri belirli bir miktar sağa kaydırıyor.
IShiftOperators<IntPtr,Int32,IntPtr>.UnsignedRightShift(IntPtr, Int32)	Değeri belirli bir miktar sağa kaydırıyor.
ISignedNumber<IntPtr>.NegativeOne	Türün -1 değerini alır.
ISubtractionOperators<IntPtr,IntPtr,IntPtr>.CheckedSubtraction(IntPtr, IntPtr)	Farklarını hesaplamak için iki değeri çıkarır.
ISubtractionOperators<IntPtr,IntPtr,IntPtr>.Subtraction(IntPtr, IntPtr)	Farklarını hesaplamak için iki değeri çıkarır.
IUnaryNegationOperators<IntPtr,IntPtr>.CheckedUnaryNegation(IntPtr)	Bir değerin denetlenen bir tekli olumsuzlamasını hesaplar.
IUnaryNegationOperators<IntPtr,IntPtr>.UnaryNegation(IntPtr)	Bir değerin tekli olumsuzlamasını hesaplar.
IUnaryPlusOperators<IntPtr,IntPtr>.UnaryPlus(IntPtr)	Bir değerin birli artısını hesaplar.

İş Parçacığı Güvenliği

Bu tür iş parçacığı güvenlidir.

Ayrıca bkz.

• UIntPtr