HandleRef or IntPtr. When and Why?

Libor Theimer

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)

13 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes12y ago
Accepted 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.
Libor Theimer12y ago
Yes, It's just a pity that he never updated it :o(

Anyway, thank you
LT
Vulpes12y ago
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.
Libor Theimer12y ago
Can you recommend any other recent book on a similar topic?
Vulpes12y ago
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.
Libor Theimer12y ago
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 Theimer12y ago
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.
Vulpes12y ago
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.
Libor Theimer12y ago
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
Vulpes12y ago
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.
Libor Theimer12y ago
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?
Vulpes12y ago
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 Theimer12y ago
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?