Q1
Sounds like you're trying to create far too many UI controls at the same time. Even if there's memory left, you're running out of handles. See below for a brief, but fairly technical explanation.
Q4
I understand a user object to be any object that is part of the GUI. At least until Windows XP, the Windows UI API resided in USER.DLL
(one of the core DLLs making up Windows). Basically, the UI is made up of "windows". All controls, such as buttons, textboxes, checkboxes, are internally the same thing, namely "windows". To create them, you'd call the Win32 API function CreateWindow
. That function would then return a handle to the created "window" (UI element, or "user object").
So I assume that a user object handle is a handle as returned by this function. (Winforms is based on the old Win32 API and would therefore use the CreateWindow
function.)
Q2
Indeed you cannot create as many UI controls as you want. All those handles retrieved through CreateWindow
must at some point be freed. In Winforms, the easiest and safest way to do this is through the use of the using
block or by calling Dispose
:
using (MyForm form = new MyForm())
{
if (form.ShowDialog() == DialogResult.OK) ...
}
Basically, all System.Windows.Forms.Control
can be Dispose
d, and should be disposed. Sometimes, that's done for you automatically, but you shouldn't rely on it. Always Dispose
your UI controls when you no longer need them.
Note on Dispose
for modal & modeless forms:
- Modal forms (shown with
ShowDialog
) are not automatically disposed. You have to do that yourself, as demonstrated in the code example above. - Modeless forms (shown with
Show
) are automatically disposed for you, since you have no control over when it will be closed by the user. No need to explicitly callDispose
!
Q5
Everytime you create a UI object, Winforms internally makes calls to CreateWindow
. That's how handles are allocated. And they're not freed until a corresponding call to DestroyWindow
is made. In Winforms, that call is triggered through the Dispose
method of any System.Windows.Forms.Control
. (Note: While I'm farily certain about this, I'm actually guessing a little. I may not be 100% correct. Having a look at Winforms internals using Reflector would reveal the truth.)
Q3
Assuming that your StrategyEditor
creates a massive bunch of UI controls, I don't think you can do a lot. If you can't simplify that control (with respect to the number of child controls it creates), then it seems you're stuck in the situation where you are. You simply can't create infinitely many UI controls.
You could, however, keep track of how many StrategyEditor
s are opened at any one time (increase a counter whenever one is instantiated, and decrease it whenever one is closed -- you can track the latter using the FormClosing
/FormClosed
event of a form, or in the Dispose
method of a control). Then you could limit the number of simultaneously opened StrategyEditor
s to a fixed number, say 5. If the limit is exceeded, you could throw an exception in the constructor, so that no more instances are created. Of course I can't say whether StrategyForm
is going to handle an exception from your StrategyEditor
constructor well...
public class StrategyEditor : ...
{
public StrategyEditor()
{
InitializeComponent();
if (numberOfLiveInstances >= maximumAllowedLiveInstances)
throw ...;
// not a nice solution IMHO, but if you've no other choice...
}
}
In either case, limiting the number of instantiated StrategyEditor
s seems like a temporary fix to me and won't solve the real problem.