Ian Griffiths & Matthew Adams
A Desktop Quick Reference
IN A NUTSHELL
.NET
WINDOWS FORMS
Controls, Forms,
Menus, GDI+ and more…
.NET WINDOWS FORMS
IN A NUTSHELL
Ian Griffiths and Matthew Adams
Beijing • Cambridge • Farnham • Köln • Paris • Sebastopol • Taipei • Tokyo
v
This is the Title of the Book, eMatter Edition
Copyright © 2002 O’Reilly & Associates, Inc. All rights reserved.
Chapter 1
Table of Contents
Preface
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ix
Part I. Introduction to Windows Forms
1. .NET and Windows Forms Overview
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
Windows Development and .NET 3
The Common Language Runtime (CLR) 5
.NET Programming Languages 10
Components 11
The .NET Type System 12
2. Controls
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
118
When To Inherit 119
Inheriting from Forms and User Controls 122
Inheriting from Other Controls 127
Pitfalls of Inheritance 136
Summary 140
7. Redrawing and GDI+
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
141
Drawing and Controls 141
GDI+ 145
Summary 196
8. Property Grids
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
197
Displaying Simple Objects 197
Type Conversion 207
Custom Type Editors 225
Summary 231
9. Controls and the IDE
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
233
Design Time vs. Runtime 233
Custom Component Designers 236
Extender Providers 264
Summary 268
10. Data Binding
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
269

389
15. The System.Drawing.Drawing2D Namespace
. . . . . . . . . . . . . . . . .
459
16. The System.Drawing.Imaging Namespace
. . . . . . . . . . . . . . . . . . . .
486
17. The System.Drawing.Printing Namespace
. . . . . . . . . . . . . . . . . . . .
515
18. The System.Drawing.Text Namespace
. . . . . . . . . . . . . . . . . . . . . . . .
537
19. The System.Windows.Forms Namespace
. . . . . . . . . . . . . . . . . . . . .
541
20. The System.Windows.Forms.Design Namespace
. . . . . . . . . . . . . . .
810
Part III. Appendixes
A. Namespaces and Assemblies
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
834
B. Type, Method, Property, Event, and Field Index
. . . . . . . . . . . . . . . .
835
Index
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
905
54

that their lifetime is managed by the .NET Framework.
Application Structure | 55
Forms, Apps,
Containers
This is the Title of the Book, eMatter Edition
Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
Startup and Shutdown
All programs have to start executing somewhere, and .NET applications have a
special method that is called when the application is run. This method is respon-
sible for creating whatever windows the application requires and performing any
other necessary initialization.
In C# and Visual Basic, this entry point is always a static method called
Main.It
doesn’t matter which class this is defined in, although Visual Studio always makes
it a member of the main form that it puts in any new project. It generates code like
the C# code shown in Example 3-1.
Although Visual Studio makes
Main visible if you’re developing with C#, it hides it
if you’re developing with Visual Basic. In Visual Basic projects, the code for
Main is
not displayed in the form’s code window, nor is it listed in Class View or in the
Object Browser. However, examining a compiled Windows Forms application
using ILDASM, the .NET disassembler, indicates that a hidden public method
named
Main is present in the application’s main form, as Figure 3-1 shows. Its
source code corresponds to that shown in Example 3-2.
Example 3-1. A typical application entry point
[STAThread]
static void Main( )
{

application’s execution for the remainder of its lifetime. The program runs until
the
Application class decides it is time to exit. By default, this is when the main
form is closed.
The Application Class
To do its job, the Windows Forms framework needs to have a high degree of
control over our application. In particular, it must respond correctly to the kind of
input that all Windows applications are required to handle, such as mouse clicks
Example 3-2. An application entry point in VB
<STAThread> Public Shared Sub Main( )
Application.Run(new Form1( ))
End Sub
Example 3-3. C# application entry point with parameters
[STAThread]
static int Main(string[] args)
{
Application.Run(new Form1( ));
}
Example 3-4. VB application entry point with parameters
<STAThread> _
Public Shared Function Main(args As String( )) As Integer
Application.Run(New Form1( ))
End Sub
Application Structure | 57
Forms, Apps,
Containers
This is the Title of the Book, eMatter Edition
Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
and redraw requests. This means the framework needs to be in charge of our appli-
cation’s main thread most of the time; otherwise, it cannot deal with these events.

to process user input makes it difficult to support any kind of Cancel button.
While the obvious solution is to avoid writing event handlers that take too long to
execute, this is not always possible. Fortunately, long-running event handlers can
choose to give the framework a chance to deal with any events that may be
queued up and awaiting processing. The
Application class provides a method
called
DoEvents. This handles any pending input and then returns. Of course, any
code that calls this method needs to be careful, because it is inviting reentrant
behavior, so whenever you call this method, you must consider the implications
of another of your event handlers being run before
DoEvents returns. But it does
mean that slow code has a way of making sure the application does not appear to
lock up completely.
The DoEvents method is not the only way of reentering the framework’s event
handling code. Whenever you display a modal dialog (e.g., by using the
MessageBox class, or by displaying a form with the ShowDialog method, as
described later), Windows Forms is once again in charge of your thread and will
process events for you for as long as the window is displayed.
* This is similar to the way that classic Win32 applications must service the message queue.
58
|
Chapter 3: Forms, Containers, and Applications
This is the Title of the Book, eMatter Edition
Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
Because the Application class effectively owns our thread, we must get its help
when we wish to shut down our program. By default, it monitors the form that we
passed to its
Run method (usually the program’s main form), and it exits when that
form closes. However, we can also force a shutdown by calling its

worker thread,
*
nor can you read or write its properties. The only exceptions to
this rule are calls to the
Invoke, BeginInvoke, and EndInvoke methods and to the
InvokeRequired property, which can all be used from any thread.
This may seem a surprisingly draconian restriction, but it is not as bad as it
sounds. It is possible to use the
Control class’s Invoke method to run code on the
right thread for the control—you just pass a delegate to the
Invoke method, and it
calls that delegate for you on the correct thread. The call will not occur until the
next time the Windows Forms framework processes messages on the control’s
thread. (This is to avoid reentrancy.)
Invoke waits for the method to complete, so
if an event is being handled by the user interface thread currently,
Invoke will wait
for that handler to finish. Beware of the potential for deadlock here;
BeginInvoke
is sometimes a better choice because it doesn’t wait for the invoked method to
finish running—it just adds the request to run the method to the framework’s
internal event queue and then returns immediately. (It is possible that your user
interface thread was waiting for your worker thread to do something, so if you
* A worker thread is any thread other than the UI thread.
The Form Class | 59
Forms, Apps,
Containers
This is the Title of the Book, eMatter Edition
Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
also make your worker thread wait for the user interface thread to do something,

You may also be wondering why Visual Studio .NET places an
STAThread attribute
on your application’s
Main function, as shown in Example 3-1. This is required for
ActiveX controls to work. If you want to use ActiveX controls, the COM runtime
must be initialized in a particular way on the user interface thread. In .NET,
COM is always initialized by the CLR, so we use this attribute to tell the CLR how
we would like it to configure COM on this thread. A full discussion of COM
interop and COM’s threading model is beyond the scope of this book, although if
you are familiar with COM, you might find it helpful to know that this attribute
ensures that the main thread will belong to an STA.
So the
Application class is responsible for managing our application’s lifetime, main
thread, and event processing. But all the interesting activity surrounds the forms
that make up our applications, so let’s now look in more detail at the
Form class.
The Form Class
All windows in a Windows Forms application are represented by objects of some
type deriving from the
Form class. Of course, Form derives from Control, as do all
classes that represent visual elements, so we have already seen much of what it
can do in the previous chapter. But we will now look at the features that the
Form
class adds.
* This particular example shows a member function of some class that derives from Control—this
is whyit is able to use the InvokeRequired and BeginInvoke members directly. This is not a require-
ment—the methods are public, so you can call them on any control.
60
|
Chapter 3: Forms, Containers, and Applications

The Designer does not make it obvious where you are expected to add any code of
your own, such as fields or methods other than event handlers. This is because it
doesn’t matter—Visual Studio .NET is pretty robust about working around you.
It is even happy for you to move most of the code that it generates if you don’t
like the way it arranges things, with the exception of the code inside the
InitializeComponent method, which you should avoid modifying by hand. (The
editor hides this code by default to discourage you from changing it.)
Initialization
Any freshly created form will contain a constructor and an InitializeComponent
method. The job of these methods is to make sure a form is correctly initialized
before it is displayed.
The generated constructor is very simple—it just calls the
InitializeComponent
method. The intent here is that the Forms Designer places all its initialization
code in
InitializeComponent, and you will write any initialization that you require
in the constructor. The designer effectively owns
InitializeComponent, and it is
recommended that you avoid modifying its contents, because this is liable to
confuse the Designer. So when you look at the source code for a form class, Visual
Studio .NET conceals the
InitializeComponent method by default—it is lurking
The Form Class | 61
Forms, Apps,
Containers
This is the Title of the Book, eMatter Edition
Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
behind a line that appears as “Windows Form Designer generated code.”
*
You can

this.textBox1.Location = new System.Drawing.Point(112, 136);
this.textBox1.Name = "textBox1";
this.textBox1.TabIndex = 2;
this.textBox1.Text = "textBox1";
this.textBox1.TextChanged += new
System.EventHandler(this.textBox1_TextChanged);
The corresponding VB code appears as follows:
Me.TextBox1.Location = New System.Drawing.Point(112, 136)
Me.TextBox1.Name = "TextBox1"
Me.TextBox1.TabIndex = 2
Me.TextBox1.Text = "TextBox1"
* It is hidden with a pair of
#region and #endregion directives. These are ignored by the compiler, but
used by the editor in Visual Studio .NET to hide parts of the file automatically behind single sum-
mary lines. You can also usethese directives yourself ifyou wantto make blocks ofcode collapsible.
62
|
Chapter 3: Forms, Containers, and Applications
This is the Title of the Book, eMatter Edition
Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
After this, the form’s size is set and then all the controls are added to its Controls
collection. (Simply creating controls and storing them in private fields is not enough
to make them appear on screen—they must be explicitly added to the form on
which they are to appear; this process will be discussed in detail later.) Finally, the
ResumeLayout method, which is inherited from the Control class, is called. This is
the counterpart of the earlier call to
SuspendLayout, and it indicates to the form that
the various additions and modifications are complete, and that it won’t be wasting
CPU cycles when it manages its layout. This call will also cause an initial layout to
be performed, causing any docked controls to be positioned appropriately.

to free the resources it is using. (Such objects usually also have finalizers, so if the
client code forgets to call
Dispose, the resources will be freed eventually, if some-
what late. But this is not an excuse for not calling the method.)
The
Control class (and therefore any class deriving from it) implements
IDisposable, as do most of the classes in GDI+, so almost everything you use in
Windows Forms programming relies on this idiom. Fortunately, the C# language
has special support for it. The
using keyword can automatically free disposable
resources for us at the end of a scope:
The Form Class | 63
Forms, Apps,
Containers
This is the Title of the Book, eMatter Edition
Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
using(Brush b = new SolidBrush(this.ForeColor))
{
do some painting with the brush
}
When the code exits the block that follows the using statement, the Brush object’s
Dispose method will be called. (The Brush class is part of GDI+, and it imple-
ments
IDisposable; this example is typical of redraw code in a custom control.)
The most important feature of this construct is that it will call
Dispose regardless
of how we leave the block. Even if the code returns from the middle of the block
or throws an exception,
Dispose will still be called, because the compiler puts this
code in a

in both scenarios—either when the user calls
IDispose.Dispose or when the final-
izer runs.
It is important to distinguish between timely disposal and finalization when
cleaning up resources. In a finalizer, it is never possible to be sure whether any
references you hold to other objects are still valid: if the runtime has determined
that your object is to be garbage collected, it is highly likely that it will also have
decided that the objects you are using must be collected too. Because the CLR
makes no guarantees of the order in which finalizers are run, it is entirely possible
*Afinally block is a block of code that the CLR guarantees to run, regardless of how the flow of
execution leaves the preceding block. It allows a single piece of cleanup code to be used in the
face of normal exit, premature returns, and exceptions.
† Strictly speaking it inherits this model from its base class, the Component class in the System.
ComponentModel namespace.
64
|
Chapter 3: Forms, Containers, and Applications
This is the Title of the Book, eMatter Edition
Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
that any objects to which you hold references have already had their finalizers run.
In this case, calling
Dispose on them could be dangerous—most objects will not
expect to have their methods called once they have been finalized. So most of the
time, your
Dispose method will only want to do anything when the object was
explicitly disposed of by the user. The only resources you would free during final-
ization would be those external to the CLR, such as any temporary files created by
your object or any handles obtained through interop.
The
Dispose method that you are intended to override is protected, so it cannot be

{
components.Dispose( );
}
}
base.Dispose( disposing );
}
Example 3-6. The default protected Dispose method in VB
Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean)
If disposing Then
If Not (components Is Nothing) Then
components.Dispose( )
End If
End If
MyBase.Dispose(disposing)
End Sub
The Form Class | 65
Forms, Apps,
Containers
This is the Title of the Book, eMatter Edition
Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
Components added to a form using the Forms Designer in Visual
Studio .NET will not necessarily be added to the form’s components
collection. Only those components with a constructor that takes a
single parameter of type IContainer will be added. (All the compo-
nents in the framework that require disposal have such a construc-
tor.) If you are writing your own component that has code in its
Dispose method, you must supply an appropriate constructor. This
constructor must call Add on the supplied container to add itself to
the components collection.
There are two very important rules you must stick to if you need to modify this

examining their constructors—if a component supplies a constructor that takes an
IContainer as a parameter, it will use that constructor, passing components as the
container.) You can also add any objects of your own to the collection:
components.Add(myDisposableObject);
or:
components.Add(myDisposableObject)
Showing Modal and Non-Modal Forms
All forms created by Visual Studio .NET will conform to the structure just
described. But as with dialogs in classic Windows applications, there are two ways
in which they can be shown: forms can exhibit either modal or non-modal behavior.
66
|
Chapter 3: Forms, Containers, and Applications
This is the Title of the Book, eMatter Edition
Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
A modal form is one that demands the user’s immediate attention, and blocks
input to any other windows the application may have open. (The application
enters a mode where it will only allow the user to access that form, hence the
name.) Forms should be displayed modally only if the application cannot proceed
until the form is satisfied. Typical examples would be error messages that must
not go unnoticed or dialogs that collect data from the user that must be supplied
before an operation can be completed (e.g., the File Open dialog—an application
needs to know which file it is supposed to load before it can open it).
You select between modal and non-modal behavior when you display the form.
The
Form class provides two methods for displaying a form: ShowDialog, which
displays the form modally, and
Show, which displays it non-modally.
The
Show method returns immediately, leaving the form on screen. (The event

programmer’s point of view, the most direct approach is to call its
Close method,
as follows:
this.Close( ); // C#
Me.Close( ) ' VB
The Form Class | 67
Forms, Apps,
Containers
This is the Title of the Book, eMatter Edition
Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
A form may also be closed automatically by the Windows Forms framework in
response to user input; for example, if the user clicks on a form’s close icon, the
window will close. However, if you want to prevent this (as you might if, for
example, the window represents an unsaved file), you can do so by handling the
Form class’s Closing event. The framework raises this event just before closing the
window, regardless of whether the window is being closed automatically or by an
explicit call to the
Close method. The event’s type is CancelEventHandler; its
Boolean
Cancel property enables us to prevent the window from closing if neces-
sary. Examples 3-7 and 3-8 illustrate the use of this property when handling the
Closing event.
Example 3-7. Handling the Closing event in C#
private void MyForm_Closing(object sender,
System.ComponentModel.CancelEventArgs e)
{
if (!IsWorkSaved( ))
{
DialogResult rc = MessageBox.Show(
"Save work before exiting?",

This is the Title of the Book, eMatter Edition
Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
The form in Examples 3-7 and 3-8 checks to see if there is unsaved work.
(
IsWorkSaved is just a fictional method for illustrating this example—it is not part
of the framework.) If there is, it displays a message box giving the user a chance to
save this work, abandon it, or cancel, which keeps the window open. In the latter
case, this code informs the framework that the window should not be closed after
all by setting the
Cancel property of the CancelEventArgs argument to true.
If you write an MDI application (i.e., an application that can display multiple
documents as children of a single main frame), the framework treats an attempt to
close the main window specially. Not only does the main window get a Closing
and Closed event, so does each child window. The child windows are asked first,
so if each child represents a different document, each child can prompt the user if
there is unsaved work. But none of the children are closed until all of the windows
(the children and the main window) have fired the
Closing event. This means the
close can be vetoed by any of the windows. The close will only happen if all the
child windows and the main window are happy.
If nothing cancels the Closing event, the window will be closed, and the Closed
event will be raised. If the form is shown non-modally, the framework then calls
the form’s
Dispose method to make sure that all the form’s resources are freed.
This means once a non-modal form has been closed, you cannot reuse the object
to display the form a second time. If you call
Show on a form that has already been
closed, an exception will be thrown. For modal dialogs, however, it is common to
want to use the form object after the window has closed. For example, if the dialog
was displayed to retrieve information from the user, you will want to get that

do not need to write a click handler to make this happen. The Windows Forms
framework will automatically close the form when any button with a
DialogResult
is clicked. So we will now look at dialog results.
Automatic button click handling
A dialog might be closed for several different reasons. Instead of clicking the OK
button, the user might attempt to cancel the dialog by clicking on its close icon or
Cancel button, or by pressing the Escape key. Most applications will distinguish
between such cancellation and normal completion, and some may make a finer
distinction still, such as a message box with Yes, No, and Cancel buttons.
Windows Forms provides support for automatically managing the various ways of
closing a window without having to write click handlers. It also makes it easy for
users of a form to find out which way a form was closed. Both of these facilities
revolve around dialog results.
The
Form class’s ShowDialog method returns a value indicating how the dialog was
dismissed. The returned value corresponds to the
DialogResult property of the
button with which the user closed the window. The following code shows an
excerpt from the initialization of a form containing two buttons,
buttonOK and
buttonCancel (the Forms Designer will generate such code if you set a button’s
DialogResult property in the Properties window):
buttonOK.DialogResult = DialogResult.OK;
buttonCancel.DialogResult = DialogResult.Cancel;
Any code that shows this dialog will be able to determine which button was
clicked from
ShowDialog’s return code. The returned value can also be retrieved
later from the
DialogResult property of the Form object.

Windows Forms framework can fake a click on the Cancel button when the
Escape key is pressed. All we need to do is tell the form which is our Cancel
button (which could be any button—it doesn’t have to be labeled Cancel)—with
the
Form class’s CancelButton property:
this.CancelButton = buttonCancel; // C#
Me.CancelButton = buttonCancel ' VB
If buttonCancel has a handler registered for its Click event, that handler will be
called either when the button is clicked, or when the Escape key is pressed. In both
cases, the same two things to happen: first, the
Click handler (if there is one) is
called, then the window is closed. The
Click handler for the button indicated by the
CancelButton property does not need to take any special steps to close the window.
The CancelButton property is ignored if the user simply closes the
window. In this case, the button’s click handler will not be called,
and its specified DialogResult will not be returned from ShowDialog.
So you will need to override the OnClosed method in your form to
handle all the possible ways of closing the dialog.
As with all buttons, if you specify a DialogResult other than None for the Cancel
button, that value will be used as the dialog result. However, the button referred
to by the
CancelButton property is unusual in that if this property is set to None,it
behaves as though it were set to
Cancel: the form will be closed, and the dialog
result will be
Cancel. (Also, when you choose a CancelButton in the Forms
Designer, it sets the button’s
DialogResult property to Cancel automatically. This
seems to be overkill, because it would return

Copyright © 2003 O’Reilly & Associates, Inc. All rights reserved.
Containment
All useful forms contain some controls. There is more to this containment rela-
tionship than meets the eye, and if you are familiar with the old Win32 parent/
child relationship, you will find that things do not work in quite the same way.
We will look at the control nesting facilities supplied by both the
Control class
and the
ContainerControl class, paying particular attention to the implications of
containment for focus and validation events.
Parents and Owners
Controls rarely exist in complete isolation—top-level windows usually contain
some controls, and all non–top-level controls are associated with a window. In
fact, Windows Forms defines two kinds of relationships between controls. There
is the parent/child relationship, which manages containment of controls within a
single window. There is also a looser association that can exist between top-level
windows, which is represented by the owner/owned relationship.
Parent and child
A child window is one that is completely contained by its parent. For example, any
controls that you place on a form are children of that form. A child’s position is
specified relative to its parent, and the child is clipped to the parent’s bounds—i.
e., only those parts of the child completely inside the parent are visible. Forms can
be children too: document windows in an MDI application are children of the
main MDI frame.
A control’s parent is accessible through its
Parent property (of type Control). If
you examine this property on a control on a form, you will typically find that it
refers to that form. However, many controls can behave as both a parent and a
child—if you place a button inside a group box on a form, the button’s parent will
be the group box, and the group box’s parent will be the form.

like this towards the end of the function in a C# project:
this.Controls.AddRange(new System.Windows.Forms.Control[] {
this.checkBox1,
this.btnCancel,
this.btnOK});
In a VB project, the code appears as follows:
Me.Controls.AddRange(New System.Windows.Forms.Control( ) _
{Me.checkBox1, Me.btnCancel, Me.btnOK})
(checkBox1, btnCancel and btnOK are controls that would have been initialized
earlier in the method.) This code would have worked equally well if the Designer
had set the
Parent property to this in C# or to Me in VB on each of these controls,
but using
Controls.AddRange is slightly more efficient, because it allows all the
controls to be attached to the form in one operation.
When nesting is in use, you will see a similar call to the
AddRange method. For
example, if you create a panel with some controls in it, those controls will be
added with a call to
Controls.AddRange on the panel. This panel itself would then
be added to the form’s
Controls collection.
A control might not have a parent—its
Parent property could be null (in C#) or
Nothing (in VB). Such controls are called top-level windows. Top-level windows
private void AnyClick(object sender, System.EventArgs e)
{
Control clicked = (Control) sender;
Debug.WriteLine(string.Format("{0} clicked", clicked.Name));
}

windows and the main windows. Unlike parenting, ownership only exists between
top-level windows, because an owned form is never contained by its owner. (For
example, undocked toolbars can usually be moved completely outside the main
window, which would not be possible if they were children of that window.)
Although an owned form may live outside or overlap its owner, it will always
appear directly in front of it in the Z-order.
†
Bringing the owner to the foreground
will cause all the forms it owns to appear in front of it. (This is not the same thing
as a top-most form, which is described below.) Bringing an owned form to the
front will have the same effect as bringing its owner to the front. Minimizing an
owner causes all its owned windows to be minimized too, although an owned
window can be minimized without minimizing the owner.
Owned windows typically don’t need their own representation on the Windows
taskbar because they are subordinate to their owners. Because activating an
owned window implicitly activates the owner and vice versa, it would merely
clutter up the taskbar to have entries for both. So owned forms normally have
their
ShowInTaskBar properties set to false.
The following code fragments (in VB and C#) show a new form being created,
owned, and displayed:
// defining an owner form in C#
MyForm ownedForm = new MyForm( );
ownedForm.ShowInTaskbar = false;
AddOwnedForm(ownedForm);
ownedForm.Show( );
* Strictly speaking, the framework allows for top-level controls that are not forms, so you should
not presume that a top-level control can necessarily be cast to Form. You can determine whether
a control is top-level from its TopLevel property.
† Windows defines a Z-order for all windows on the screen. It determines which windows are on