Richtige IntPtr verwenden, die in C#

Ich denke ich verstehe die Verwendung von IntPtr, aber ich bin mir wirklich nicht sicher.

Kopierte ich die IDisposable-pattern aus der MSDN, nur um zu sehen, was ich kriegen konnte, und während ich verstehen, dass es für die meisten Teil, ich habe keine Ahnung wie ich das implementieren eines IntPtr richtig, oder gar verstehen, was es ist, es soll ein "Punkt" zu, oder Referenz. Auf top von, dass, ich haben keine Idee, wie Sie auch zuweisen, oder werfen ein integer, string, char, double, etc. um einen IntPtr einen Zeiger zu erstellen, aus ihm heraus.

Auch, IntPtr erfordern, unsicheren code verwenden?

Sowieso, hier ist etwas code, um ein Bild zu malen von dem, was ich Rede:

namespace Utilities
{   
    class Disposer : IDisposable
    {

        private IntPtr handle;

        private Component component = new Component(); 

        private bool disposed = false;

        public Disposer(IntPtr handle)
        {
            this.handle = handle;

        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if(!this.disposed)
            {
                if (disposing)
                {
                    component.Dispose(); 
                }
                CloseHandle(handle);

                handle = IntPtr.Zero;

                disposed = true;

            }
        }

        [System.Runtime.InteropServices.DllImport("Kernal32")]
        private extern static Boolean CloseHandle(IntPtr handle);
    }



    public unsafe class ExecuteMain
    {
        Object nuller = new Object();

        byte boa = 0;

        byte *blargh = boa;

        public static void Main()
        { 

        }
    }
}

Auch, könnte mir jemand sagen was der Punkt, der die Komponente hier ist, genau? Ich bin auch Schwierigkeiten Umhüllung meinem Kopf, um dieses Konzept als gut.

  • unklar ist, was deine Frage eigentlich ist?
  • Wenn Sie nur versuchen, die Spur ein handle auf einen Windows-kernel-Objekt ist, verwenden Sie eine SafeHandle: msdn.microsoft.com/en-us/library/...
InformationsquelleAutor zeboidlund | 2011-05-23
  1. 12

    Können Sie verwenden, IntPtr Objekte auf diese Weise: 

            int test = 55;

        //Allocating memory for int
        IntPtr intPointer = Marshal.AllocHGlobal(sizeof(int));

        Marshal.WriteInt32(intPointer,test);

        //sending intPointer to unmanaged code here

        //Test reading of IntPtr object
        int test2 = Marshal.ReadInt32(intPointer); //test2 would be equal 55

        //Free memory
        Marshal.FreeHGlobal(intPointer);

    Erkunden Sie andere Marschall Methode zu verstehen, wie zu schreiben, string -, Doppel-und etc zu IntPtr.

    Also Wörter über Ihre code - es ist nicht eine gute Idee, Sie zu entsorgen externen zugewiesen nicht verwalteten Objekts. Sollten Sie entsorgen einzige Objekt, das Sie zugeordnet haben, im Konstruktor der Klasse. Dies ist keine strenge Regel, sondern eine Art von guter Praxis.

    • Vielen Dank an alle. Dies scheint ein wenig mehr klar. Ich bin mir sicher, dass ich verstanden werde es bald genug.
    InformationsquelleAutor Anton Semenov
  2. 4

    IntPtr (dieser link sagt eigentlich viel von dem, was ich tun) ist eine Besondere form der Ganzzahl, die die Größe der Zeiger für die aktuellen bit-ness-der Prozess-die Größe von 4 bytes im 32-bit-x86, 8 bytes in 64-bit-x86, dies entspricht der Größe eines Zeigers.

    Während Sie verweisen auf einen Ort im Speicher, es muss nicht. Wie in den geposteten code, es konnte nur finden, ein Handgriff oder andere undurchsichtige Nummer. Es ist wichtig, weil von der Größe von änderungen in den P/Aufgerufen wird system-Aufrufe (system calls benutzen Sie Konstanten-sized integer, während einige abhängig von der Architektur und Zeiger sind immer Architektur abhängig). Ein IntPtr muss nicht entsorgt werden, sondern die undurchsichtige Anzahl in Ihr enthaltenen verweisen möglicherweise auf eine Ressource, die nicht braucht, loslassen; all dies ist Teil des API-Vertrages, mit dem der Wert ermittelt wurde.

    Sehen new IntPtr(long) und IntPtr.ToInt32/ToInt64 für Umwandlungen zu/von einem standard-numerischen Typ (auf einem 64-bit-Umgebung ist es möglich, dass ToInt32 wirft einen overflow-exception).

    Und Nein, beim abrufen eines Werts für die IntPtr (z.B. Aufruf von P/Aufgerufene Funktion) erfordern kann, die die entsprechenden Sicherheitseinstellungen Berechtigungen, es gibt keine unsicher - code erforderlich (siehe link, oder was unsafe erlaubt) -- aber wohl nichts, dass die Gespräche, nativer code ist "unsicher" wie kann es zu einer Nizza-Prozess zum Absturz bringen 😉

    Happy coding.

    InformationsquelleAutor
  3. 3

    Einer IntPtr ist nur ein Wert geben Sie die Größe entspricht der Größe der Zeiger auf die Ziel-Plattform. Sie müssen es verwenden, vor allem beim Umgang mit nicht verwalteten Zeiger. Ein IntPtr selbst nicht entsorgt werden, denn es gibt nur einen Ort im Speicher. Ihre Bereinigung werden muss spezifisch auf das Objekt bezeichnet, die durch die IntPtr. Angenommen, Sie haben eine nicht verwaltete Funktion muss ein Fenster-handle seine Arbeit zu tun. In diesem Fall können Sie die Eigenschaft Control.Handle um einen Zeiger auf das Fenster-handle des Steuerelements. Richtig Aufräumen der Steuerungs-und seine zugrunde liegende Fenster, die Sie nicht haben, um zu kümmern sich um die IntPtr bezieht sich auf die nicht verwalteten verarbeiten, sondern entsorgen Sie die Kontrolle.

    [DllImport("UnmanagedLibrary.dll")]
private static void DoSomethingWithWindowHandle(IntPtr windowHandle);

private void Foo()
{
    Form form = new Form();
    //...
    DoSomethingWithWindowHandle(form.Handle);
    //...
    form.Dispose();
}
    InformationsquelleAutor Florian Greinacher
  4. 2

    IntPtr ist ein integer, der die Größe eines Zeigers, 32 bit auf 32-bit-Systeme und 64 bit auf 64 bit Systemen. Es wird normalerweise verwendet, um wickeln Sie einen Zeiger oder ein handle zu übergeben, um eine nicht verwaltete Funktion, wie Sie getan haben. "unsicher" bedeutet, dass Sie mit Zeigern in C# - code, so IntPtrs außerhalb von unsafe-Blöcke oder mit heraus, so dass unsicherer code kompiliert werden.

    Ich kann auch nicht sagen, was der Punkt, die Komponente, aber es wirklich, wirklich sollte nicht existieren. Griffe sollten im Besitz von einem Objekt, das stellt die Funktionalität, dass der Griff steht und verantwortlich für die Verwaltung, die Griff-Lebenszyklus. Eine Klasse, die nur willkürlich geschlossen Griffe, die es nicht zuordnen, ist erschreckend schlechten design.

    InformationsquelleAutor Yaur
Schreibe einen Kommentar