.NET Component Inspector
Have you ever wished you could explore the behavior of a
component or some code without having to write any code? To watch
events occur on any object and examine the history of events? To
quickly try something and see how it affects the component? To
look at the visual behavior of a component as you adjust not only
its properties, but execute its methods?
If so the .NET Component Inspector is the tool you have
The Component Inspector allows you to:
- open any .NET assembly (executable or library), any number
of which can be opened at once;
- trace events on any object by simple one click event
registration either on all events for an object or selected events;
- create any object from a class in the opened assemblies using drag/drop;
- create Controls on the design surface, move, resize or embed
them in other Controls;
- search for types or object content.
- use the same set of Control objects both in design mode and
normal running mode and go back and forth between the two with a
- examine or alter any field or property in the created
objects, regardless of visibility;
- execute any method on the created objects, regardless of
- quickly examine and manipulate objects in common collections
(IList, IDictionary) without concern of the implementation
details of the collections. For example, you can cut/copy/paste
objects to/from lists;
- directly execute an application, class, or Control without
writing any code; and
- explore the contents of assemblies and the Global Assembly
Compare the .NET Component Inspector
with other tools/products.
Click image for full size
You can drag a control, specified in either the Controls or
Assemblies/Types panel to either the Design Surface or the Objects
panel. When you do this, not only does the Control appear, but
the Control's object appears in the Objects panel. The Objects
panel has a completely general structure that allows you to
examine or modify any field or property (regardless of
visibility), as shown below with the modification of the Anchor
You may also invoke a method (the return result of the method is
recorded in the Objects tree so that you can examine it).
This structure is similar to that provided by the Visual Studio
.NET debugger with some important differences:
- Commonly used things like lists are presented in an easy to
use fashion as simply a list of objects (see "Top-Level Object"
in the Event Logging screenshot below).
- You may modify the values of fields or properties and invoke
methods within the tree.
- The static type structure of superclasses is not presented,
making it much easier to navigate.
Click image to make it small again
This screenshot is an example of event logging, where all of the events
for a TreeView are being logged. The TreeView is shown in
execution (non-design) mode. You see the events that have occurred
in the Event Log panel. On the BeforeExpand event, you can see
that the stack trace associated with this event is shown, and on
the Objects panel (on the left), the event object is shown, with
the Node property opened up.
Another powerful feature is the event incarnation number. This
shows which events are causally related. For example, the Click,
MouseDown, BeforeExpand, and AfterExpand events are all related (as
shown because they all have number 31).
Panes of the Inspector
- Objects - A tree of all known objects.
The tree shows all of the members of the object's class
including fields, properties, and methods.
The current values of the members is also shown.
For example, if you call a given
method, the return value of the method is shown.
- Parameters - Provides the mechanism for detailed display and
input of values for method parameters and fields/properties.
Allows any type of value to be specified (including
structures, colors, objects, etc).
- Control Design Surface - Controls are created
here and can
be moved, resized or embedded in other controls. This can be
either in design mode (served by the control's designer), or in
actual runtime mode so you can see the behavior of the running
- Assemblies/Types - Shows all of the open assemblies
with their type information. This is similar to the type
browser in VS.NET. You can select a class in this tree and drag
it to the either Object Tree (or Control Design Surface if a Control)
and it will create the object. If there are multiple
constructors, you can select the constructor to use.
- Controls - Shows only the Control classes of the
presently open assemblies. This is done to allow you to quickly
access controls. The Controls panel is organized by namespace,
and beneath the Control classes the organization is the same as
the Assemblies/Types panel.
- GAC - The Global Accembly Cache (GAC) presented
in the same manner as the Windows explorer. You can open
assemblies from this panel, and they then appear on the
- Event Log - The Event Log panel contains a row for
each occurrence of an event that is being logged. Each row
contains the information about the event. A context menu allows
you to display the event object or sending object in the Objects
- Events Being Logged - This panel provides a concise
view of the events being logged. A context menu allows you to
disable logging for a given event or events.
- Detail Information - At the bottom, detailed information
about the item selected in the upper panels is shown.