IntPtr Yapı

Tanım

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

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, 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 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 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,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
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, 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 IShiftOperators<nativeint, int, nativeint>
    interface IMinMaxValue<nativeint>
    interface ISignedNumber<nativeint>
    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, 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
type nativeint = struct
    interface IFormattable
    interface IParsable<nativeint>
    interface ISpanFormattable
    interface ISpanParsable<nativeint>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<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 IShiftOperators<nativeint, int, 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, 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)
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)
Public Structure IntPtr
Implements IEquatable(Of IntPtr), ISerializable
Public Structure IntPtr
Implements ISerializable
Devralma
IntPtr
Öznitelikler
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 nesneyi başlatıp uzunluğunu aldıktan sonra aşağıdakileri yapar:

  1. Unicode dizesini Marshal.StringToHGlobalAnsi yönetilmeyen belleğe ANSI (bir bayt) karakteri olarak kopyalamak için yöntemini çağırır. yöntemi, yönetilmeyen dizenin başlangıcına işaret eden bir IntPtr nesne 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. Marshal.AllocHGlobal Yönetilmeyen dizenin kapladıkça aynı sayıda bayt ayırmak için yöntemini çağırır. yöntemi, yönetilmeyen bellek bloğunun başına işaret eden bir IntPtr nesne 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 adlı offset 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 ToPointer başlangıç adresine ve yönetilmeyen bellek bloğuna yönetilmeyen bir işaretçi almak için yöntemini çağırır ve ANSI dizesinin başlangıç adresine dizenin uzunluğundan bir daha azını 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 bir baytlık karakter) okumak için yöntemini çağırır Marshal.ReadByte(IntPtr, Int32) . Uzaklık, döngünün her yinelemesiyle artırılır. Ardından bayt değerini Marshal.WriteByte(IntPtr, Int32, Byte) yönetilmeyen bellek bloğunun başlangıç adresi artı offsetile tanımlanan bellek adresine yazmak için yöntemini çağırır. Daha sonra azalmış olur offset.

    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 kadar artırır.

  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 öğesini çağırırMarshal.PtrToStringAnsi.

  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 yöntemini çağırır FreeHGlobal .

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

Tür IntPtr , 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.

Tür, IntPtr 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, örnekleri dosya tanıtıcılarını IntPtr tutmak için sınıfında kapsamlı olarak System.IO.FileStream kullanılır.

Not

İşaretçi veya tanıtıcı olarak kullanmak IntPtr hataya açıktır ve güvenli değildir. Yalnızca aynı boyutta olması nedeniyle işaretçiler ve tanıtıcılar için değişim biçimi olarak kullanılabilecek 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ı SafeHandle temsil etmek için kullanılmalıdır.

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

Sürüm 9.0'dan başlayarak C# dilinde nint , yerel boyutlu tamsayıları tanımlamak için yerleşik türünü kullanabilirsiniz. Bu tür, türüyle IntPtr 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# dilinde sürüm 11'den başlayarak ve .NET 7 veya üzeri çalışma zamanını hedeflerken, nint için diğer adla IntPtr aynı şekilde int bir diğer addır Int32.

Oluşturucular

IntPtr(Int32)

Belirtilen 32 bit imzalı tamsayıyı kullanarak yeni bir örneğini IntPtr başlatır.

IntPtr(Int64)

Belirtilen 64 bit imzalı tamsayıyı kullanarak yeni bir örneğini IntPtr başlatır.

IntPtr(Void*)

Belirtilmemiş bir tür için belirtilen işaretçiyi kullanarak yeni bir örneğini IntPtr 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 değerini IntPtralır.

MinValue

mümkün olan en küçük değerini IntPtralır.

Size

Bu örneğin boyutunu alır.

Yöntemler

Abs(IntPtr)

Bir değerin mutlak değerini hesaplar.

Add(IntPtr, Int32)

İmzalı bir tamsayıya uzaklık ekler.

Clamp(IntPtr, IntPtr, IntPtr)

Bir değeri kapsayıcı bir minimum ve maksimum değere kelepçeler.

CompareTo(IntPtr)

Mevcut örneği aynı türdeki başka bir nesne ile karşılaştırır ve geçerli örneğin, diğer nesneyle aynı sıralama düzeni konumunda mı olduğunu, önünde mi olduğunu, yoksa arkasında mı olduğunu belirten bir tamsayı döndürür.

CompareTo(Object)

Mevcut örneği aynı türdeki başka bir nesne ile karşılaştırır ve geçerli örneğin, diğer nesneyle aynı sıralama düzeni konumunda mı olduğunu, önünde mi olduğunu, yoksa arkasında mı olduğunu 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)

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 tüm değerleri doygunluğa 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 keserek.

DivRem(IntPtr, IntPtr)

İki değerin bölümünü ve kalanı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ğeri döndürür.

GetHashCode()

Bu örneğe ilişkin karma kodu döndürür.

IsEvenInteger(IntPtr)

Bir değerin çift tam sayı olup olmadığını belirler.

IsNegative(IntPtr)

Bir değerin negatif olup olmadığını belirler.

IsOddInteger(IntPtr)

Bir değerin tek integralli bir sayıyı temsil eder 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 log2'sini hesaplar.

Max(IntPtr, IntPtr)

İki değeri daha büyük olan işlemle karşılaştırır.

MaxMagnitude(IntPtr, IntPtr)

İki değeri daha büyük olan işlemle karşılaştırır.

Min(IntPtr, IntPtr)

daha küçük olan iki değeri işlemle karşılaştırır.

MinMagnitude(IntPtr, IntPtr)

daha küçük 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)

Belirli bir stildeki ve kültüre özgü biçimdeki bir sayının 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)

Belirtilen 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)

Belirli bir miktar tarafından bırakılan bir değeri döndürür.

RotateRight(IntPtr, Int32)

Değeri belirli bir miktarda 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 nesnenin sayısal değerini eşdeğer dize gösterimine dönüştürür.

ToString(IFormatProvider)

Bu örneğin sayısal değerini belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak eşdeğer dize gösterimine dönüştürür.

ToString(String)

Geçerli IntPtr nesnenin 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çimlendirebilir.

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 belirtilen bayt aralığına UTF-8 olarak 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)

Belirli bir stildeki ve kültüre özgü biçimdeki 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(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ı bir 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 değerine IntPtrdönüştürür.

Explicit(Int64 to IntPtr)

64 bit imzalı tamsayı değerini değerine 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ğildir.

Explicit(Void* to IntPtr)

Belirtilen işaretçiyi belirtilmemiş bir türe IntPtrdönüştürür.

Bu API, CLS uyumlu değildir.

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()

öğesinin bir parçası TryWriteLittleEndian(Span<Byte>, Int32)olarak yazılacak bayt sayısını alır.

IBinaryInteger<IntPtr>.GetShortestBitLength()

En kısa ikinin geçerli değerin 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 yayılmaya yazmaya çalışır.

IBinaryInteger<IntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)

Küçük endian biçimindeki geçerli değeri belirli bir yayılmaya 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ğerlerini 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 dışlayıcı değerini hesaplar.

IBitwiseOperators<IntPtr,IntPtr,IntPtr>.OnesComplement(IntPtr)

Belirli bir değerin bireyi 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)

Değeri azaltma.

IDecrementOperators<IntPtr>.Decrement(IntPtr)

Değeri azaltma.

IDivisionOperators<IntPtr,IntPtr,IntPtr>.Division(IntPtr, IntPtr)

Bölümlerini hesaplamak için bir değeri diğerine böler.

IEquatable<IntPtr>.Equals(IntPtr)

Bu örneğin başka bir imzalı tamsayıya eşit olup olmadığını gösteren bir değer döndürür.

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 küçü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)

Çarpımlarını hesaplamak için iki değeri çarpar.

IMultiplyOperators<IntPtr,IntPtr,IntPtr>.Multiply(IntPtr, IntPtr)

Çarpımlarını hesaplamak için iki değeri çarpar.

INumber<IntPtr>.MaxNumber(IntPtr, IntPtr)

daha büyük olan ve giriş NaNise diğer değeri döndüren iki değeri ile karşılaştırır.

INumber<IntPtr>.MinNumber(IntPtr, IntPtr)

daha küçük olan ve giriş ise diğer değeri döndüren iki değeri hesapla karşılaştırır NaN.

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 eder olup olmadığını belirler.

INumberBase<IntPtr>.IsFinite(IntPtr)

Bir değerin sınırlı olup olmadığını belirler.

INumberBase<IntPtr>.IsImaginaryNumber(IntPtr)

Bir değerin yalnızca sanal bir sayıyı temsil eder olup olmadığını belirler.

INumberBase<IntPtr>.IsInfinity(IntPtr)

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 sonsuzluk olup olmadığını belirler.

INumberBase<IntPtr>.IsNormal(IntPtr)

Bir değerin normal olup olmadığını belirler.

INumberBase<IntPtr>.IsPositiveInfinity(IntPtr)

Bir değerin sonsuzluk değerinin pozitif olup olmadığını belirler.

INumberBase<IntPtr>.IsRealNumber(IntPtr)

Bir değerin gerçek bir sayıyı temsil eder 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)

İki değeri, daha büyük bir büyüklüğe sahip olan ve giriş ise diğer değeri döndüren işlemle karşılaştırır NaN.

INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr, IntPtr)

daha küçük bir büyüklüğe sahip olan ve giriş ise diğer değeri döndüren iki değeri hesapla karşılaştırır NaN.

INumberBase<IntPtr>.One

Türün değerini 1 alır.

INumberBase<IntPtr>.Radix

Türün sayı tabanını 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 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ürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan tüm değerleri keser.

INumberBase<IntPtr>.Zero

Türün değerini 0 alır.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Bir SerializationInfo nesneyi geçerli IntPtr nesneyi seri hale getirmek için gereken verilerle doldurur.

IShiftOperators<IntPtr,Int32,IntPtr>.LeftShift(IntPtr, Int32)

Belirli bir miktarın solunda kalan bir değeri kaydırıyor.

IShiftOperators<IntPtr,Int32,IntPtr>.RightShift(IntPtr, Int32)

Değeri belirli bir tutara göre sağa kaydırıyor.

IShiftOperators<IntPtr,Int32,IntPtr>.UnsignedRightShift(IntPtr, Int32)

Değeri belirli bir tutara göre sağa kaydırıyor.

ISignedNumber<IntPtr>.NegativeOne

Türün değerini -1 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 tekil 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.

Şunlara uygulanır

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

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

Ayrıca bkz.