HandleRef or IntPtr. When and Why?

Question

In what cases is it better to use HandleRef instead IntPtr in PInvoke. Is there something like best practices ? I need use it in Win32 functions like GetWindow, GetWindowText, SetWindowText etc. User can close any window anytime so hwnd in not valid anymore.

For example:

1. get hwnd by function GetWindow for Notepad window

2. user close Notepad window so my hwnd is invalid

3. using this hwnd in SetWindowText will crashed

Is it possible solve this problem by HandleRef? I think no, but I am beginner in .NET.

Thanks to all :o)

Vulpes · Answer

If you pass a handle to a managed object to an unmanaged function using P/invoke then if there are no other references to the object it is possible that the object will be garbage collected before the P/invoke call completes thereby invalidating the handle and causing an error. if you wrap the handle in a HandleRef rather than passing it as an IntPtr this will ensure that the managed object is not garbage collected until the P/invoke call has completed and is therefore a sensible precaution to take in these circumstances. However it won't help with any of the situations you've mentioned because a Notepad window is not of course a managed object. As there's not normally anything you can do to prevent a user from closing a window the best thing to do is to obtain the handle each time you want to perform an operation or a series of consecutive operations rather than rely on a previously obtained handle still being valid and to always check for an error code after each operation.

Vulpes · Answer

TBH I can't :( Many other books cover COM interop and Platform Invoke to some extent but I don't know of any book which covers them in the same depth as Nathan's book. It's just a pity that he never updated it. However I think that nowadays most .NET programmers rely on internet articles and the PInvoke.net website to cover their interop needs. C# wrappers have been written for a lot of the more important stuff anyway and so it's no longer as important a topic as it once was.

Vulpes · Answer

As it's a different question and you've started a new thread I've answered it there. However I'll just say here that the quote is from a well known book on interoperability by Adam Nathan which was published in the early days of .NET (2002). It would not therefore be any great surprise if the book contained errors or even that the GC itself contained errors which have since been corrected.

Vulpes · Answer

You're right that you can wrap the IntPtr in a HandleRef outside the class as well as inside the class and your example should therefore work. The important thing is that the HandleRef is passed to the unmanaged function and the prototype for the latter needs to be declared accordingly. The P/invoke marshaller 'knows' about the HandleRef type and will only pass the handle itself to the unmanaged function. The object reference will be used to keep the object alive until the call is completed.

Vulpes · Answer

Well it's not a great example but I think the point it's making is nevertheless fairly clear. If hdcscreen was an IntPtr rather than a HandleRef and the Test class instance was garbage collected before the call to GetGraphicsMode completed then the Finalize method would release the device context and you'd get an error. By making it a HandleRef instead you prevent the Test class instance from being GC'ed before the call to GetGraphicsMode completes and so the DC is still valid.

Vulpes · Answer

When a managed object exposes a handle it is generally a handle to some unmanaged resource which the managed object holds. Usually such objects implement the IDisposable interface and as a prelude to GC you call the object's Dispose() method to free the unmanaged resource. Such objects also usually have a destructor and before GC takes place the code in the destructor checks whether the unmanaged resource has already been released and if it hasn't releases it. In the MS Support example the Test class is just a simple managed wrapper for a device context which it exposes via the hdcscreen field. Although the Test class doesn't implement IDisposable it's destructor (Finalize method in VB.NET) makes sure the DC has been released before the object is GC'ed. So again the handle is being wrapped in a HandleRef to make sure the Test class object is not GC'ed before the P/Invoke call to the unmanaged function GetGraphicsMode is completed.

Libor Theimer · Answer

Yes It's just a pity that he never updated it :o( Anyway thank you LT

Libor Theimer · Answer

Can you recommend any other recent book on a similar topic?

Libor Theimer · Answer

I have found example in book .NET and COM: The Complete Interoperability Guide but I'am not sure if explanation of this example is correct http://www.c-sharpcorner.com/Forums/Thread/258844/is-it-possible-free-obj-instance-inside-its-method.aspx

Libor Theimer · Answer

Thank you very much!!! Now I understand better. I looked for a long time on the internet but I never found examples with detailed explanations of how exactly use HandleRef. Misusing the Handleref would create the type of errors that are very difficult to find.

Libor Theimer · Answer

if I understand it well. it is possible to make relation between class Test and variable hdcscreen through HandleRef from inside of class as is in the example as well as from outside of class . I edited example and marked changes by red. Is it possible to write code this way? I understand that original example is better because user do not need to worry about anything but functionality is (maybe) the same for both examples. Isnt't it? My solution is usable for a foreign classes contaning handle type IntPtr like in this example http://msdn.microsoft.com/en-us/library/hc662t8k%28v=vs.110%29.aspx. There is impossible make relation inside class because I dont have source code so I need make relation outside class. Class Test Public hdcscreen As IntPtr Public Sub New() hdcscreen = GetDC(IntPtr.Zero) End Sub Protected Overrides Sub Finalize() Dim ret As Integer ret = ReleaseDC(IntPtr.Zero hdcscreen) MyBase.Finalize() End Sub End Class Sub Main() Dim mvb As New Test() Dim abc as Handleref = New HandleRef(mvb mvb.hdcscreen) Dim GrMode As Integer GrMode = GetGraphicsMode( abc ) Console.Write(GrMode.ToString) End Sub

Libor Theimer · Answer

Hi I know how use IDisposable. My question was. Is it using HandleRef in mentioned example rational? I think no it isn't. And this example is confusing. Isn't it?

Libor Theimer · Answer

Thank you. But I have found example (the first one) on http://support.microsoft.com/kb/309327/en-us and I dont understand it. Variable hdcscreen will exist as long as instance of class Test so why hdcscreen is HandleRef? It could be IntPtr because it is impossible to GC this variable inside instance of Test class. And second ambiguity. hdcscreen doesn't point to managed code so it can't be GC. I understand this correctly ?