IntPtr Estrutura

  • Referência

Definição

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Representa um inteiro com sinal em que a largura do bit é igual a um ponteiro.

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 : 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 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 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 IEquatable(Of IntPtr), ISerializable
Public Structure IntPtr
Implements ISerializable
Herança
Object
ValueType
IntPtr
Atributos
SerializableAttribute ComVisibleAttribute
Implementações
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>

Exemplos

O exemplo a seguir usa ponteiros gerenciados para reverter os caracteres em uma matriz. Depois que ele inicializa um String objeto e obtém seu comprimento, ele faz o seguinte:

  1. Chama o Marshal.StringToHGlobalAnsi método para copiar a cadeia de caracteres Unicode para memória não gerenciada como um caractere ANSI (um byte). O método retorna um IntPtr objeto que aponta para o início da cadeia de caracteres não gerenciada. O exemplo do Visual Basic usa esse ponteiro diretamente; nos exemplos C++, F# e C#, ele é convertido em um ponteiro para um byte.

  2. Chama o Marshal.AllocHGlobal método para alocar o mesmo número de bytes que a cadeia de caracteres não gerenciada ocupa. O método retorna um IntPtr objeto que aponta para o início do bloco de memória não gerenciado. O exemplo do Visual Basic usa esse ponteiro diretamente; nos exemplos C++, F# e C#, ele é convertido em um ponteiro para um byte.

  3. O exemplo do Visual Basic define uma variável chamada offset que é igual ao comprimento da cadeia de caracteres ANSI. Ele é usado para determinar o deslocamento para a memória não gerenciada para a qual o próximo caractere na cadeia de caracteres ANSI é copiado. Como seu valor inicial é o comprimento da cadeia de caracteres, a operação de cópia copiará um caractere do início da cadeia de caracteres até o final do bloco de memória.

    Os exemplos de C#, F# e C++ chamam o ToPointer método para obter um ponteiro não gerenciado para o endereço inicial da cadeia de caracteres e o bloco de memória não gerenciado e adicionam um menor que o comprimento da cadeia de caracteres ao endereço inicial da cadeia de caracteres ANSI. Como o ponteiro de cadeia de caracteres não gerenciado agora aponta para o final da cadeia de caracteres, a operação de cópia copiará um caractere do final da cadeia de caracteres para o início do bloco de memória.

  4. Usa um loop para copiar cada caractere da cadeia de caracteres para o bloco de memória não gerenciado.

    O exemplo do Visual Basic chama o Marshal.ReadByte(IntPtr, Int32) método para ler o byte (ou caractere de um byte) em um deslocamento especificado do ponteiro gerenciado para a cadeia de caracteres ANSI. O deslocamento é incrementado com cada iteração do loop. Em seguida, ele chama o Marshal.WriteByte(IntPtr, Int32, Byte) método para gravar o byte no endereço de memória definido pelo endereço inicial do bloco de memória não gerenciado mais offset. Em seguida, diminui offset.

    Os exemplos de C#, F# e C++ executam a operação de cópia e, em seguida, decrementam o ponteiro para o endereço do próximo local na cadeia de caracteres ANSI não gerenciada e incrementam o ponteiro para o próximo endereço no bloco não gerenciado.

  5. Todos os exemplos chamam o Marshal.PtrToStringAnsi para converter o bloco de memória não gerenciado que contém a cadeia de caracteres ANSI copiada para um objeto Unicode String gerenciado.

  6. Depois de exibir as cadeias de caracteres originais e invertidas, todos os exemplos chamam o FreeHGlobal método para liberar a memória alocada para a cadeia de caracteres ANSI não gerenciada e o bloco de memória não gerenciado.

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

Comentários

O IntPtr tipo foi projetado para ser um inteiro cujo tamanho é o mesmo que um ponteiro. Ou seja, espera-se que uma instância desse tipo seja de 32 bits em um processo de 32 bits e 64 bits em um processo de 64 bits.

O IntPtr tipo pode ser usado por idiomas que dão suporte a ponteiros e como um meio comum de fazer referência a dados entre idiomas que fazem e não dão suporte a ponteiros.

IntPtr objetos também podem ser usados para manter identificadores. Por exemplo, as instâncias de IntPtr são usadas extensivamente na System.IO.FileStream classe para manter identificadores de arquivo.

Observação

Usar IntPtr como ponteiro ou identificador é propenso a erros e não seguro. É simplesmente um tipo inteiro que pode ser usado como um formato de intercâmbio para ponteiros e identificadores devido ao mesmo tamanho. Fora dos requisitos específicos de intercâmbio, como para passar dados para um idioma que não dá suporte a ponteiros, um ponteiro digitado corretamente deve ser usado para representar ponteiros e SafeHandle deve ser usado para representar identificadores.

Esse tipo implementa o ISerializable. No .NET 5 e versões posteriores, esse tipo também implementa as IFormattable interfaces. No .NET 7 e versões posteriores, esse tipo também implementa as IBinaryInteger<TSelf>interfaces , IMinMaxValue<TSelf>e ISignedNumber<TSelf> .

No C# a partir da versão 9.0, você pode usar o tipo interno nint para definir inteiros de tamanho nativo. Esse tipo é representado pelo IntPtr tipo internamente e fornece operações e conversões apropriadas para tipos inteiros. Para obter mais informações, consulte tipos nint e nuint.

No C# a partir da versão 11 e ao direcionar o runtime do .NET 7 ou posterior, nint é um alias para IntPtr da mesma forma que int é um alias para Int32.

Construtores

IntPtr(Int32)

Inicializa uma nova instância do IntPtr usando o inteiro com sinal de 32 bits especificado.
IntPtr(Int64)

Inicializa uma nova instância do IntPtr usando o inteiro com sinal de 64 bits especificado.
IntPtr(Void*)

Inicializa uma nova instância do IntPtr usando o ponteiro especificado para um tipo não especificado.

Campos

Zero

Um campo somente leitura que representa um inteiro com sinal que foi inicializado como zero.

Propriedades

MaxValue

Obtém o maior valor possível de IntPtr.
MinValue

Obtém o menor valor possível de IntPtr.
Size

Obtém o tamanho dessa instância.

Métodos

Abs(IntPtr)

Calcula o absoluto de um valor.
Add(IntPtr, Int32)

Adiciona um deslocamento a um inteiro com sinal.
Clamp(IntPtr, IntPtr, IntPtr)

Fixa um valor a um valor mínimo inclusivo e máximo.
CompareTo(IntPtr)

Compara a instância atual com outro objeto do mesmo tipo e retorna um inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição da ordem de classificação do outro objeto.
CompareTo(Object)

Compara a instância atual com outro objeto do mesmo tipo e retorna um inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição da ordem de classificação do outro objeto.
CopySign(IntPtr, IntPtr)

Copia o sinal de um valor para o sinal de outro valor.
CreateChecked<TOther>(TOther)

Cria uma instância do tipo atual de um valor, gerando uma exceção de estouro para todos os valores que ficam fora do intervalo representável do tipo atual.
CreateSaturating<TOther>(TOther)

Cria uma instância do tipo atual de um valor, saturando todos os valores que ficam fora do intervalo representável do tipo atual.
CreateTruncating<TOther>(TOther)

Cria uma instância do tipo atual de um valor, truncando todos os valores que ficam fora do intervalo representável do tipo atual.
DivRem(IntPtr, IntPtr)

Calcula o quociente e o restante de dois valores.
Equals(IntPtr)

Indica se o objeto atual é igual a outro objeto do mesmo tipo.
Equals(Object)

Retorna um valor que indica se a instância é igual a um objeto especificado.
GetHashCode()

Retorna o código hash para a instância.
IsEvenInteger(IntPtr)

Determina se um valor representa um número integral par.
IsNegative(IntPtr)

Determina se um valor é negativo.
IsOddInteger(IntPtr)

Determina se um valor representa um número integral ímpar.
IsPositive(IntPtr)

Determina se um valor é positivo.
IsPow2(IntPtr)

Determina se um valor é uma potência de dois.
LeadingZeroCount(IntPtr)

Calcula o número de zeros à esquerda em um valor.
Log2(IntPtr)

Calcula o log2 de um valor.
Max(IntPtr, IntPtr)

Compara dois valores com a computação, que é maior.
MaxMagnitude(IntPtr, IntPtr)

Compara dois valores com a computação, que é maior.
Min(IntPtr, IntPtr)

Compara dois valores com a computação que é menor.
MinMagnitude(IntPtr, IntPtr)

Compara dois valores com a computação que é menor.
Parse(ReadOnlySpan<Char>, IFormatProvider)

Analisa um intervalo de caracteres em um valor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Converte o intervalo somente leitura de representação de caracteres de um número em um formato específico de estilo e cultura especificado em seu inteiro nativo com sinal equivalente.
Parse(String)

Converte a representação da cadeia de caracteres de um número no inteiro nativo com sinal equivalente.
Parse(String, IFormatProvider)

Converte a representação de cadeia de caracteres de um número em um formato indicado específico à cultura no seu inteiro nativo com sinal equivalente.
Parse(String, NumberStyles)

Converte a representação de cadeia de caracteres de um número em um estilo especificado no inteiro nativo com sinal equivalente.
Parse(String, NumberStyles, IFormatProvider)

Converte a representação de cadeia de caracteres de um número em um formato indicado específico de estilo e cultura no seu inteiro nativo com sinal equivalente.
PopCount(IntPtr)

Calcula o número de bits definidos em um valor.
RotateLeft(IntPtr, Int32)

Gira um valor deixado por um determinado valor.
RotateRight(IntPtr, Int32)

Gira um valor para a direita em um determinado valor.
Sign(IntPtr)

Calcula o sinal de um valor.
Subtract(IntPtr, Int32)

Subtrai um deslocamento de um inteiro com sinal.
ToInt32()

Converte o valor desta instância em um inteiro com sinal de 32 bits.
ToInt64()

Converte o valor desta instância em um inteiro com sinal de 64 bits.
ToPointer()

Converte o valor dessa instância em um ponteiro para um tipo não especificado.
ToString()

Converte o valor numérico do objeto IntPtr atual na representação da cadeia de caracteres equivalente.
ToString(IFormatProvider)

Converte o valor numérico dessa instância na representação da cadeia de caracteres equivalente usando o formato especificado e as informações de formato específicas da cultura especificada.
ToString(String)

Converte o valor numérico do objeto IntPtr atual na representação da cadeia de caracteres equivalente.
ToString(String, IFormatProvider)

Formata o valor da instância atual usando o formato especificado.
TrailingZeroCount(IntPtr)

Calcula o número de zeros à direita em um valor.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Tenta formatar o valor da instância atual no intervalo fornecido de caracteres.
TryParse(ReadOnlySpan<Char>, IFormatProvider, IntPtr)

Tenta analisar uma cadeia de caracteres em um valor.
TryParse(ReadOnlySpan<Char>, IntPtr)

Converte o intervalo somente leitura de representação de caracteres de um número em seu inteiro nativo com sinal equivalente. Um valor retornado indica se a conversão foi bem-sucedida.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, IntPtr)

Converte o intervalo somente leitura de representação de caracteres de um número em um formato específico de estilo e cultura especificado em seu inteiro nativo com sinal equivalente. Um valor retornado indica se a conversão foi bem-sucedida.
TryParse(String, IFormatProvider, IntPtr)

Tenta analisar uma cadeia de caracteres em um valor.
TryParse(String, IntPtr)

Converte a representação da cadeia de caracteres de um número no inteiro nativo com sinal equivalente. Um valor retornado indica se a conversão foi bem-sucedida.
TryParse(String, NumberStyles, IFormatProvider, IntPtr)

Converte a representação de cadeia de caracteres de um número em um formato indicado específico de estilo e cultura no seu inteiro nativo com sinal equivalente. Um valor retornado indica se a conversão foi bem-sucedida.

Operadores

Addition(IntPtr, Int32)

Adiciona um deslocamento a um inteiro com sinal.
Equality(IntPtr, IntPtr)

Determina se duas instâncias especificadas do IntPtr são iguais.
Explicit(Int32 to IntPtr)

Converte o valor de um inteiro com sinal de 32 bits em um IntPtr.
Explicit(Int64 to IntPtr)

Converte o valor de um inteiro com sinal de 64 bits em um IntPtr.
Explicit(IntPtr to Int32)

Converte o valor do IntPtr especificado em um inteiro com sinal de 32 bits.
Explicit(IntPtr to Int64)

Converte o valor do IntPtr especificado em um inteiro com sinal de 64 bits.
Explicit(IntPtr to Void*)

Converte o valor do IntPtr especificado em um ponteiro para um tipo não especificado.

Esta API não compatível com CLS.
Explicit(Void* to IntPtr)

Converte o ponteiro especificado em um tipo não especificado para um IntPtr.

Esta API não compatível com CLS.
Inequality(IntPtr, IntPtr)

Determina se duas instâncias especificadas de IntPtr não são iguais.
Subtraction(IntPtr, Int32)

Subtrai um deslocamento de um inteiro com sinal.

Implantações explícitas de interface

IBinaryInteger<IntPtr>.GetByteCount()

Obtém o número de bytes que serão gravados como parte de TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<IntPtr>.GetShortestBitLength()

Obtém o comprimento, em bits, da representação complementar dos dois mais curtos do valor atual.
IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<Byte>, Int32)

Tenta gravar o valor atual, no formato big-endian, em um determinado intervalo.
IBinaryInteger<IntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)

Tenta gravar o valor atual, no formato little-endian, em um determinado intervalo.
IEquatable<IntPtr>.Equals(IntPtr)

Retorna um valor que indica se essa instância é igual a outro inteiro com sinal.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Popula um objeto SerializationInfo com os dados necessários para serializar o objeto IntPtr atual.

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.

Confira também